using System;
using System.Collections.Generic;
using System.Net;
using System.Threading.Tasks;
using FS.Cache.Redis.Attribute;
using StackExchange.Redis;

namespace FS.Cache.Redis;

[TrackRedis]
public class LinkTrackWarp : IDatabase
{
    private readonly IDatabase _db;

    public LinkTrackWarp(IDatabase db)
    {
        _db = db;
    }

    public int            Database                                          => _db.Database;
    public Task<TimeSpan> PingAsync(CommandFlags flags = CommandFlags.None) => _db.PingAsync(flags: flags);
    public TimeSpan       Ping(CommandFlags      flags = CommandFlags.None) => _db.Ping(flags: flags);

    public bool TryWait(Task          task)  => _db.TryWait(task: task);
    public void Wait(Task             task)  => _db.Wait(task: task);
    public T    Wait<T>(Task<T>       task)  => _db.Wait(task: task);
    public void WaitAll(params Task[] tasks) => _db.WaitAll(tasks: tasks);

    public IConnectionMultiplexer Multiplexer => _db.Multiplexer;

    public bool IsConnected(RedisKey key, CommandFlags flags = CommandFlags.None) => _db.IsConnected(key: key, flags: flags);

    public Task<RedisValue> DebugObjectAsync(RedisKey key, CommandFlags flags = CommandFlags.None) => _db.DebugObjectAsync(key: key, flags: flags);

    public       Task<bool>                  GeoAddAsync(RedisKey                     key,         double       longitude,      double         latitude, RedisValue member, CommandFlags flags = CommandFlags.None) => _db.GeoAddAsync(key: key, longitude: longitude, latitude: latitude, member: member, flags: flags);
    public       Task<bool>                  GeoAddAsync(RedisKey                     key,         GeoEntry     value,          CommandFlags   flags                 = CommandFlags.None)                                      => _db.GeoAddAsync(key: key, value: value, flags: flags);
    public       Task<long>                  GeoAddAsync(RedisKey                     key,         GeoEntry[]   values,         CommandFlags   flags                 = CommandFlags.None)                                      => _db.GeoAddAsync(key: key, values: values, flags: flags);
    public       Task<bool>                  GeoRemoveAsync(RedisKey                  key,         RedisValue   member,         CommandFlags   flags                 = CommandFlags.None)                                      => _db.GeoRemoveAsync(key: key, member: member, flags: flags);
    public       Task<double?>               GeoDistanceAsync(RedisKey                key,         RedisValue   member1,        RedisValue     member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None) => _db.GeoDistanceAsync(key: key, member1: member1, member2: member2, unit: unit, flags: flags);
    public       Task<string[]>              GeoHashAsync(RedisKey                    key,         RedisValue[] members,        CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoHashAsync(key: key, members: members, flags: flags);
    public       Task<string>                GeoHashAsync(RedisKey                    key,         RedisValue   member,         CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoHashAsync(key: key, member: member, flags: flags);
    public       Task<GeoPosition?[]>        GeoPositionAsync(RedisKey                key,         RedisValue[] members,        CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoPositionAsync(key: key, members: members, flags: flags);
    public       Task<GeoPosition?>          GeoPositionAsync(RedisKey                key,         RedisValue   member,         CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoPositionAsync(key: key, member: member, flags: flags);
    public       Task<GeoRadiusResult[]>     GeoRadiusAsync(RedisKey                  key,         RedisValue   member,         double         radius,    GeoUnit        unit = GeoUnit.Meters, int            count         = -1,             Order? order         = null, GeoRadiusOptions options       = GeoRadiusOptions.Default, CommandFlags     flags          = CommandFlags.None)                                                => _db.GeoRadiusAsync(key: key, member: member, radius: radius, unit: unit, count: count, order: order, options: options, flags: flags);
    public       Task<GeoRadiusResult[]>     GeoRadiusAsync(RedisKey                  key,         double       longitude,      double         latitude,  double         radius,                GeoUnit        unit          = GeoUnit.Meters, int    count         = -1,   Order?           order         = null,                     GeoRadiusOptions options        = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => _db.GeoRadiusAsync(key: key, longitude: longitude, latitude: latitude, radius: radius, unit: unit, count: count, order: order, options: options, flags: flags);
    public       Task<GeoRadiusResult[]>     GeoSearchAsync(RedisKey                  key,         RedisValue   member,         GeoSearchShape shape,     int            count = -1,            bool           demandClosest = true,           Order? order         = null, GeoRadiusOptions options       = GeoRadiusOptions.Default, CommandFlags     flags          = CommandFlags.None)                                                                                     => _db.GeoSearchAsync(key, member, shape, count, demandClosest, order, options, flags);
    public       Task<GeoRadiusResult[]>     GeoSearchAsync(RedisKey                  key,         double       longitude,      double         latitude,  GeoSearchShape shape,                 int            count         = -1,             bool   demandClosest = true, Order?           order         = null,                     GeoRadiusOptions options        = GeoRadiusOptions.Default, CommandFlags flags          = CommandFlags.None)                             => _db.GeoSearchAsync(key, longitude, latitude, shape, count, demandClosest, order, options, flags);
    public       Task<long>                  GeoSearchAndStoreAsync(RedisKey          sourceKey,   RedisKey     destinationKey, RedisValue     member,    GeoSearchShape shape,                 int            count         = -1,             bool   demandClosest = true, Order?           order         = null,                     bool             storeDistances = false,                    CommandFlags flags          = CommandFlags.None)                             => _db.GeoSearchAndStoreAsync(sourceKey, destinationKey, member, shape, count, demandClosest, order, storeDistances, flags);
    public       Task<long>                  GeoSearchAndStoreAsync(RedisKey          sourceKey,   RedisKey     destinationKey, double         longitude, double         latitude,              GeoSearchShape shape,                          int    count         = -1,   bool             demandClosest = true,                     Order?           order          = null,                     bool         storeDistances = false, CommandFlags flags = CommandFlags.None) => _db.GeoSearchAndStoreAsync(sourceKey, destinationKey, longitude, latitude, shape, count, demandClosest, order, storeDistances, flags);
    public       Task<long>                  HashDecrementAsync(RedisKey              key,         RedisValue   hashField,      long           value = 1, CommandFlags   flags = CommandFlags.None) => _db.HashDecrementAsync(key: key, hashField: hashField, value: value, flags: flags);
    public       Task<double>                HashDecrementAsync(RedisKey              key,         RedisValue   hashField,      double         value,     CommandFlags   flags = CommandFlags.None) => _db.HashDecrementAsync(key: key, hashField: hashField, value: value, flags: flags);
    public       Task<bool>                  HashDeleteAsync(RedisKey                 key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashDeleteAsync(key: key, hashField: hashField, flags: flags);
    public       Task<long>                  HashDeleteAsync(RedisKey                 key,         RedisValue[] hashFields,     CommandFlags   flags = CommandFlags.None) => _db.HashDeleteAsync(key: key, hashFields: hashFields, flags: flags);
    public       Task<bool>                  HashExistsAsync(RedisKey                 key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashExistsAsync(key: key, hashField: hashField, flags: flags);
    public async Task<RedisValue>            HashGetAsync(RedisKey                    key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => await _db.HashGetAsync(key: key, hashField: hashField, flags: flags);
    public       Task<Lease<byte>>           HashGetLeaseAsync(RedisKey               key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashGetLeaseAsync(key: key, hashField: hashField, flags: flags);
    public       Task<RedisValue[]>          HashGetAsync(RedisKey                    key,         RedisValue[] hashFields,     CommandFlags   flags = CommandFlags.None) => _db.HashGetAsync(key: key, hashFields: hashFields, flags: flags);
    public       Task<HashEntry[]>           HashGetAllAsync(RedisKey                 key,         CommandFlags flags                   = CommandFlags.None)                         => _db.HashGetAllAsync(key: key, flags: flags);
    public       Task<long>                  HashIncrementAsync(RedisKey              key,         RedisValue   hashField, long   value = 1, CommandFlags flags = CommandFlags.None) => _db.HashIncrementAsync(key: key, hashField: hashField, value: value, flags: flags);
    public       Task<double>                HashIncrementAsync(RedisKey              key,         RedisValue   hashField, double value,     CommandFlags flags = CommandFlags.None) => _db.HashIncrementAsync(key: key, hashField: hashField, value: value, flags: flags);
    public       Task<RedisValue[]>          HashKeysAsync(RedisKey                   key,         CommandFlags flags                                          = CommandFlags.None)                                                                => _db.HashKeysAsync(key: key, flags: flags);
    public       Task<long>                  HashLengthAsync(RedisKey                 key,         CommandFlags flags                                          = CommandFlags.None)                                                                => _db.HashLengthAsync(key: key, flags: flags);
    public       Task<RedisValue>            HashRandomFieldAsync(RedisKey            key,         CommandFlags flags                                          = CommandFlags.None)                                                                => _db.HashRandomFieldAsync(key, flags);
    public       Task<RedisValue[]>          HashRandomFieldsAsync(RedisKey           key,         long         count,           CommandFlags flags            = CommandFlags.None)                                                                => _db.HashRandomFieldsAsync(key, count, flags);
    public       Task<HashEntry[]>           HashRandomFieldsWithValuesAsync(RedisKey key,         long         count,           CommandFlags flags            = CommandFlags.None)                                                                => _db.HashRandomFieldsWithValuesAsync(key, count, flags);
    public       IAsyncEnumerable<HashEntry> HashScanAsync(RedisKey                   key,         RedisValue   pattern = new(), int          pageSize         = 250, long cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => _db.HashScanAsync(key: key, pattern: pattern, pageSize: pageSize, cursor: cursor, pageOffset: pageOffset, flags: flags);
    public       Task                        HashSetAsync(RedisKey                    key,         HashEntry[]  hashFields,      CommandFlags flags            = CommandFlags.None)                                   => _db.HashSetAsync(key: key, hashFields: hashFields, flags: flags);
    public       Task<bool>                  HashSetAsync(RedisKey                    key,         RedisValue   hashField,       RedisValue   value, When when = When.Always, CommandFlags flags = CommandFlags.None) => _db.HashSetAsync(key: key, hashField: hashField, value: value, when: when, flags: flags);
    public       Task<long>                  HashStringLengthAsync(RedisKey           key,         RedisValue   hashField,       CommandFlags flags = CommandFlags.None) => _db.HashStringLengthAsync(key: key, hashField: hashField, flags: flags);
    public       Task<RedisValue[]>          HashValuesAsync(RedisKey                 key,         CommandFlags flags                      = CommandFlags.None) => _db.HashValuesAsync(key: key, flags: flags);
    public       Task<bool>                  HyperLogLogAddAsync(RedisKey             key,         RedisValue   value,  CommandFlags flags = CommandFlags.None) => _db.HyperLogLogAddAsync(key: key, value: value, flags: flags);
    public       Task<bool>                  HyperLogLogAddAsync(RedisKey             key,         RedisValue[] values, CommandFlags flags = CommandFlags.None) => _db.HyperLogLogAddAsync(key: key, values: values, flags: flags);
    public       Task<long>                  HyperLogLogLengthAsync(RedisKey          key,         CommandFlags flags                                               = CommandFlags.None) => _db.HyperLogLogLengthAsync(key: key, flags: flags);
    public       Task<long>                  HyperLogLogLengthAsync(RedisKey[]        keys,        CommandFlags flags                                               = CommandFlags.None) => _db.HyperLogLogLengthAsync(keys: keys, flags: flags);
    public       Task                        HyperLogLogMergeAsync(RedisKey           destination, RedisKey     first,      RedisKey     second, CommandFlags flags = CommandFlags.None) => _db.HyperLogLogMergeAsync(destination: destination, first: first, second: second, flags: flags);
    public       Task                        HyperLogLogMergeAsync(RedisKey           destination, RedisKey[]   sourceKeys, CommandFlags flags = CommandFlags.None) => _db.HyperLogLogMergeAsync(destination: destination, sourceKeys: sourceKeys, flags: flags);
    public       Task<EndPoint>              IdentifyEndpointAsync(RedisKey           key = new(), CommandFlags flags                                   = CommandFlags.None)                                                => _db.IdentifyEndpointAsync(key: key, flags: flags);
    public       Task<bool>                  KeyCopyAsync(RedisKey                    sourceKey,   RedisKey     destinationKey, int destinationDatabase = -1, bool replace = false, CommandFlags flags = CommandFlags.None) => _db.KeyCopyAsync(sourceKey, destinationKey, destinationDatabase, replace, flags);
    public       Task<bool>                  KeyDeleteAsync(RedisKey                  key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyDeleteAsync(key: key, flags: flags);
    public       Task<long>                  KeyDeleteAsync(RedisKey[]                keys,        CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyDeleteAsync(keys: keys, flags: flags);
    public       Task<byte[]>                KeyDumpAsync(RedisKey                    key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyDumpAsync(key: key, flags: flags);
    public       Task<string>                KeyEncodingAsync(RedisKey                key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyEncodingAsync(key, flags);
    public       Task<bool>                  KeyExistsAsync(RedisKey                  key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyExistsAsync(key: key, flags: flags);
    public       Task<long>                  KeyExistsAsync(RedisKey[]                keys,        CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyExistsAsync(keys: keys, flags: flags);
    public       Task<bool>                  KeyExpireAsync(RedisKey                  key,         TimeSpan?    expiry, CommandFlags flags = CommandFlags.None)                                         => _db.KeyExpireAsync(key: key, expiry: expiry, flags: flags);
    public       Task<bool>                  KeyExpireAsync(RedisKey                  key,         TimeSpan?    expiry, ExpireWhen   when  = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => _db.KeyExpireAsync(key, expiry, when, flags);
    public       Task<bool>                  KeyExpireAsync(RedisKey                  key,         DateTime?    expiry, CommandFlags flags = CommandFlags.None)                                         => _db.KeyExpireAsync(key: key, expiry: expiry, flags: flags);
    public       Task<bool>                  KeyExpireAsync(RedisKey                  key,         DateTime?    expiry, ExpireWhen   when  = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => _db.KeyExpireAsync(key, expiry, when, flags);
    public       Task<DateTime?>             KeyExpireTimeAsync(RedisKey              key,         CommandFlags flags                        = CommandFlags.None) => _db.KeyExpireTimeAsync(key, flags);
    public       Task<long?>                 KeyFrequencyAsync(RedisKey               key,         CommandFlags flags                        = CommandFlags.None) => _db.KeyFrequencyAsync(key, flags);
    public       Task<TimeSpan?>             KeyIdleTimeAsync(RedisKey                key,         CommandFlags flags                        = CommandFlags.None) => _db.KeyIdleTimeAsync(key: key, flags: flags);
    public       Task<bool>                  KeyMoveAsync(RedisKey                    key,         int          database, CommandFlags flags = CommandFlags.None) => _db.KeyMoveAsync(key: key, database: database, flags: flags);
    public       Task<bool>                  KeyPersistAsync(RedisKey                 key,         CommandFlags flags = CommandFlags.None) => _db.KeyPersistAsync(key: key, flags: flags);
    public       Task<RedisKey>              KeyRandomAsync(CommandFlags              flags                                      = CommandFlags.None)                                   => _db.KeyRandomAsync(flags: flags);
    public       Task<long?>                 KeyRefCountAsync(RedisKey                key, CommandFlags flags                    = CommandFlags.None)                                   => _db.KeyRefCountAsync(key, flags);
    public       Task<bool>                  KeyRenameAsync(RedisKey                  key, RedisKey     newKey, When      when   = When.Always, CommandFlags flags = CommandFlags.None) => _db.KeyRenameAsync(key: key, newKey: newKey, when: when, flags: flags);
    public       Task                        KeyRestoreAsync(RedisKey                 key, byte[]       value,  TimeSpan? expiry = null,        CommandFlags flags = CommandFlags.None) => _db.KeyRestoreAsync(key: key, value: value, expiry: expiry, flags: flags);
    public       Task<TimeSpan?>             KeyTimeToLiveAsync(RedisKey              key, CommandFlags flags = CommandFlags.None) => _db.KeyTimeToLiveAsync(key: key, flags: flags);
    public       Task<RedisType>             KeyTypeAsync(RedisKey                    key, CommandFlags flags = CommandFlags.None) => _db.KeyTypeAsync(key: key, flags: flags);

    public Task<RedisValue>                   ListGetByIndexAsync(RedisKey                            key,             long                index, CommandFlags flags                     = CommandFlags.None) => _db.ListGetByIndexAsync(key: key, index: index, flags: flags);
    public Task<long>                         ListInsertAfterAsync(RedisKey                           key,             RedisValue          pivot, RedisValue   value, CommandFlags flags = CommandFlags.None) => _db.ListInsertAfterAsync(key: key, pivot: pivot, value: value, flags: flags);
    public Task<long>                         ListInsertBeforeAsync(RedisKey                          key,             RedisValue          pivot, RedisValue   value, CommandFlags flags = CommandFlags.None) => _db.ListInsertBeforeAsync(key: key, pivot: pivot, value: value, flags: flags);
    public Task<RedisValue>                   ListLeftPopAsync(RedisKey                               key,             CommandFlags        flags                       = CommandFlags.None)                                                                                          => _db.ListLeftPopAsync(key: key, flags: flags);
    public Task<RedisValue[]>                 ListLeftPopAsync(RedisKey                               key,             long                count,   CommandFlags flags = CommandFlags.None)                                                                                          => _db.ListLeftPopAsync(key: key, count: count, flags: flags);
    public Task<ListPopResult>                ListLeftPopAsync(RedisKey[]                             keys,            long                count,   CommandFlags flags = CommandFlags.None)                                                                                          => _db.ListLeftPopAsync(keys, count, flags);
    public Task<long>                         ListPositionAsync(RedisKey                              key,             RedisValue          element, long         rank  = 1,          long         maxLength = 0, CommandFlags flags     = CommandFlags.None)                         => _db.ListPositionAsync(key, element, rank, maxLength, flags);
    public Task<long[]>                       ListPositionsAsync(RedisKey                             key,             RedisValue          element, long         count,              long         rank      = 1, long         maxLength = 0, CommandFlags flags = CommandFlags.None) => _db.ListPositionsAsync(key, element, count, rank, maxLength, flags);
    public Task<long>                         ListLeftPushAsync(RedisKey                              key,             RedisValue          value,   When         when = When.Always, CommandFlags flags     = CommandFlags.None) => _db.ListLeftPushAsync(key: key, value: value, when: when, flags: flags);
    public Task<long>                         ListLeftPushAsync(RedisKey                              key,             RedisValue[]        values,  When         when = When.Always, CommandFlags flags     = CommandFlags.None) => _db.ListLeftPushAsync(key: key, values: values, when: when, flags: flags);
    public Task<long>                         ListLeftPushAsync(RedisKey                              key,             RedisValue[]        values,  CommandFlags flags) => _db.ListLeftPushAsync(key: key, values: values, flags: flags);
    public Task<long>                         ListLengthAsync(RedisKey                                key,             CommandFlags        flags                                                                                 = CommandFlags.None) => _db.ListLengthAsync(key: key, flags: flags);
    public Task<RedisValue>                   ListMoveAsync(RedisKey                                  sourceKey,       RedisKey            destinationKey, ListSide sourceSide, ListSide     destinationSide, CommandFlags flags = CommandFlags.None) => _db.ListMoveAsync(sourceKey, destinationKey, sourceSide, destinationSide, flags);
    public Task<RedisValue[]>                 ListRangeAsync(RedisKey                                 key,             long                start = 0,      long     stop  = -1, CommandFlags flags = CommandFlags.None) => _db.ListRangeAsync(key: key, start: start, stop: stop, flags: flags);
    public Task<long>                         ListRemoveAsync(RedisKey                                key,             RedisValue          value,          long     count = 0,  CommandFlags flags = CommandFlags.None) => _db.ListRemoveAsync(key: key, value: value, count: count, flags: flags);
    public Task<RedisValue>                   ListRightPopAsync(RedisKey                              key,             CommandFlags        flags                           = CommandFlags.None)                                   => _db.ListRightPopAsync(key: key, flags: flags);
    public Task<RedisValue[]>                 ListRightPopAsync(RedisKey                              key,             long                count,       CommandFlags flags = CommandFlags.None)                                   => _db.ListRightPopAsync(key: key, count: count, flags: flags);
    public Task<ListPopResult>                ListRightPopAsync(RedisKey[]                            keys,            long                count,       CommandFlags flags = CommandFlags.None)                                   => _db.ListRightPopAsync(keys, count, flags);
    public Task<RedisValue>                   ListRightPopLeftPushAsync(RedisKey                      source,          RedisKey            destination, CommandFlags flags = CommandFlags.None)                                   => _db.ListRightPopLeftPushAsync(source: source, destination: destination, flags: flags);
    public Task<long>                         ListRightPushAsync(RedisKey                             key,             RedisValue          value,       When         when  = When.Always, CommandFlags flags = CommandFlags.None) => _db.ListRightPushAsync(key: key, value: value, when: when, flags: flags);
    public Task<long>                         ListRightPushAsync(RedisKey                             key,             RedisValue[]        values,      When         when  = When.Always, CommandFlags flags = CommandFlags.None) => _db.ListRightPushAsync(key: key, values: values, when: when, flags: flags);
    public Task<long>                         ListRightPushAsync(RedisKey                             key,             RedisValue[]        values,      CommandFlags flags)                                          => _db.ListRightPushAsync(key: key, values: values, flags: flags);
    public Task                               ListSetByIndexAsync(RedisKey                            key,             long                index,       RedisValue   value,  CommandFlags flags = CommandFlags.None) => _db.ListSetByIndexAsync(key: key, index: index, value: value, flags: flags);
    public Task                               ListTrimAsync(RedisKey                                  key,             long                start,       long         stop,   CommandFlags flags = CommandFlags.None) => _db.ListTrimAsync(key: key, start: start, stop: stop, flags: flags);
    public Task<bool>                         LockExtendAsync(RedisKey                                key,             RedisValue          value,       TimeSpan     expiry, CommandFlags flags = CommandFlags.None) => _db.LockExtendAsync(key: key, value: value, expiry: expiry, flags: flags);
    public Task<RedisValue>                   LockQueryAsync(RedisKey                                 key,             CommandFlags        flags                                            = CommandFlags.None) => _db.LockQueryAsync(key: key, flags: flags);
    public Task<bool>                         LockReleaseAsync(RedisKey                               key,             RedisValue          value,   CommandFlags flags                      = CommandFlags.None) => _db.LockReleaseAsync(key: key, value: value, flags: flags);
    public Task<bool>                         LockTakeAsync(RedisKey                                  key,             RedisValue          value,   TimeSpan     expiry, CommandFlags flags = CommandFlags.None) => _db.LockTakeAsync(key: key, value: value, expiry: expiry, flags: flags);
    public Task<long>                         PublishAsync(RedisChannel                               channel,         RedisValue          message, CommandFlags flags = CommandFlags.None) => _db.PublishAsync(channel: channel, message: message, flags: flags);
    public Task<RedisResult>                  ExecuteAsync(string                                     command,         params object[]     args)                                                                                                                                          => _db.ExecuteAsync(command: command, args: args);
    public Task<RedisResult>                  ExecuteAsync(string                                     command,         ICollection<object> args,                                                  CommandFlags flags                      = CommandFlags.None)                            => _db.ExecuteAsync(command: command, args: args, flags: flags);
    public Task<RedisResult>                  ScriptEvaluateAsync(string                              script,          RedisKey[]          keys       = null,                                     RedisValue[] values                     = null, CommandFlags flags = CommandFlags.None) => _db.ScriptEvaluateAsync(script: script, keys: keys, values: values, flags: flags);
    public Task<RedisResult>                  ScriptEvaluateAsync(byte[]                              hash,            RedisKey[]          keys       = null,                                     RedisValue[] values                     = null, CommandFlags flags = CommandFlags.None) => _db.ScriptEvaluateAsync(hash: hash, keys: keys, values: values, flags: flags);
    public Task<RedisResult>                  ScriptEvaluateAsync(LuaScript                           script,          object              parameters = null,                                     CommandFlags flags                      = CommandFlags.None) => _db.ScriptEvaluateAsync(script: script, parameters: parameters, flags: flags);
    public Task<RedisResult>                  ScriptEvaluateAsync(LoadedLuaScript                     script,          object              parameters = null,                                     CommandFlags flags                      = CommandFlags.None) => _db.ScriptEvaluateAsync(script: script, parameters: parameters, flags: flags);
    public Task<bool>                         SetAddAsync(RedisKey                                    key,             RedisValue          value,                                                 CommandFlags flags                      = CommandFlags.None) => _db.SetAddAsync(key: key, value: value, flags: flags);
    public Task<long>                         SetAddAsync(RedisKey                                    key,             RedisValue[]        values,                                                CommandFlags flags                      = CommandFlags.None) => _db.SetAddAsync(key: key, values: values, flags: flags);
    public Task<RedisValue[]>                 SetCombineAsync(SetOperation                            operation,       RedisKey            first,                                                 RedisKey     second, CommandFlags flags = CommandFlags.None) => _db.SetCombineAsync(operation: operation, first: first, second: second, flags: flags);
    public Task<RedisValue[]>                 SetCombineAsync(SetOperation                            operation,       RedisKey[]          keys,                                                  CommandFlags flags                                          = CommandFlags.None) => _db.SetCombineAsync(operation: operation, keys: keys, flags: flags);
    public Task<long>                         SetCombineAndStoreAsync(SetOperation                    operation,       RedisKey            destination,                                           RedisKey     first, RedisKey     second, CommandFlags flags = CommandFlags.None) => _db.SetCombineAndStoreAsync(operation: operation, destination: destination, first: first, second: second, flags: flags);
    public Task<long>                         SetCombineAndStoreAsync(SetOperation                    operation,       RedisKey            destination,                                           RedisKey[]   keys,  CommandFlags flags = CommandFlags.None) => _db.SetCombineAndStoreAsync(operation: operation, destination: destination, keys: keys, flags: flags);
    public Task<bool>                         SetContainsAsync(RedisKey                               key,             RedisValue          value,                                                 CommandFlags flags = CommandFlags.None) => _db.SetContainsAsync(key: key, value: value, flags: flags);
    public Task<bool[]>                       SetContainsAsync(RedisKey                               key,             RedisValue[]        values,                                                CommandFlags flags = CommandFlags.None) => _db.SetContainsAsync(key, values, flags);
    public Task<long>                         SetIntersectionLengthAsync(RedisKey[]                   keys,            long                limit                                             = 0, CommandFlags flags = CommandFlags.None) => _db.SetIntersectionLengthAsync(keys, limit, flags);
    public Task<long>                         SetLengthAsync(RedisKey                                 key,             CommandFlags        flags                                             = CommandFlags.None) => _db.SetLengthAsync(key: key, flags: flags);
    public Task<RedisValue[]>                 SetMembersAsync(RedisKey                                key,             CommandFlags        flags                                             = CommandFlags.None) => _db.SetMembersAsync(key: key, flags: flags);
    public Task<bool>                         SetMoveAsync(RedisKey                                   source,          RedisKey            destination, RedisValue value, CommandFlags flags = CommandFlags.None) => _db.SetMoveAsync(source: source, destination: destination, value: value, flags: flags);
    public Task<RedisValue>                   SetPopAsync(RedisKey                                    key,             CommandFlags        flags                     = CommandFlags.None) => _db.SetPopAsync(key: key, flags: flags);
    public Task<RedisValue[]>                 SetPopAsync(RedisKey                                    key,             long                count, CommandFlags flags = CommandFlags.None) => _db.SetPopAsync(key: key, count: count, flags: flags);
    public Task<RedisValue>                   SetRandomMemberAsync(RedisKey                           key,             CommandFlags        flags                                                = CommandFlags.None)                                                                                                                                                                                                    => _db.SetRandomMemberAsync(key: key, flags: flags);
    public Task<RedisValue[]>                 SetRandomMembersAsync(RedisKey                          key,             long                count,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                    => _db.SetRandomMembersAsync(key: key, count: count, flags: flags);
    public Task<bool>                         SetRemoveAsync(RedisKey                                 key,             RedisValue          value,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                    => _db.SetRemoveAsync(key: key, value: value, flags: flags);
    public Task<long>                         SetRemoveAsync(RedisKey                                 key,             RedisValue[]        values,                          CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                    => _db.SetRemoveAsync(key: key, values: values, flags: flags);
    public Task<RedisValue[]>                 SortAsync(RedisKey                                      key,             long                skip = 0,                        long          take  = -1, Order         order = Order.Ascending, SortType sortType = SortType.Numeric, RedisValue by       = new(),            RedisValue[] get = null,  CommandFlags flags = CommandFlags.None)                            => _db.SortAsync(key: key, skip: skip, take: take, order: order, sortType: sortType, by: by, get: get, flags: flags);
    public Task<long>                         SortAndStoreAsync(RedisKey                              destination,     RedisKey            key,                             long          skip  = 0,  long          take  = -1,              Order    order    = Order.Ascending,  SortType   sortType = SortType.Numeric, RedisValue   by  = new(), RedisValue[] get   = null, CommandFlags flags = CommandFlags.None) => _db.SortAndStoreAsync(destination: destination, key: key, skip: skip, take: take, order: order, sortType: sortType, by: by, get: get, flags: flags);
    public Task<bool>                         SortedSetAddAsync(RedisKey                              key,             RedisValue          member,                          double        score,      CommandFlags  flags)                                                               => _db.SortedSetAddAsync(key: key, member: member, score: score, flags: flags);
    public Task<bool>                         SortedSetAddAsync(RedisKey                              key,             RedisValue          member,                          double        score,      When          when = When.Always,          CommandFlags flags = CommandFlags.None) => _db.SortedSetAddAsync(key: key, member: member, score: score, when: when, flags: flags);
    public Task<bool>                         SortedSetAddAsync(RedisKey                              key,             RedisValue          member,                          double        score,      SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => _db.SortedSetAddAsync(key, member, score, when, flags);
    public Task<long>                         SortedSetAddAsync(RedisKey                              key,             SortedSetEntry[]    values,                          CommandFlags  flags)                                                                                                                                                  => _db.SortedSetAddAsync(key: key, values: values, flags: flags);
    public Task<long>                         SortedSetAddAsync(RedisKey                              key,             SortedSetEntry[]    values,                          When          when    = When.Always,          CommandFlags flags     = CommandFlags.None)                                                                             => _db.SortedSetAddAsync(key: key, values: values, when: when, flags: flags);
    public Task<long>                         SortedSetAddAsync(RedisKey                              key,             SortedSetEntry[]    values,                          SortedSetWhen when    = SortedSetWhen.Always, CommandFlags flags     = CommandFlags.None)                                                                             => _db.SortedSetAddAsync(key, values, when, flags);
    public Task<RedisValue[]>                 SortedSetCombineAsync(SetOperation                      operation,       RedisKey[]          keys,                            double[]      weights = null,                 Aggregate    aggregate = Aggregate.Sum, CommandFlags flags     = CommandFlags.None)                                     => _db.SortedSetCombineAsync(operation, keys, weights, aggregate, flags);
    public Task<SortedSetEntry[]>             SortedSetCombineWithScoresAsync(SetOperation            operation,       RedisKey[]          keys,                            double[]      weights = null,                 Aggregate    aggregate = Aggregate.Sum, CommandFlags flags     = CommandFlags.None)                                     => _db.SortedSetCombineWithScoresAsync(operation, keys, weights, aggregate, flags);
    public Task<long>                         SortedSetCombineAndStoreAsync(SetOperation              operation,       RedisKey            destination,                     RedisKey      first,                          RedisKey     second,                    Aggregate    aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => _db.SortedSetCombineAndStoreAsync(operation: operation, destination: destination, first: first, second: second, aggregate: aggregate, flags: flags);
    public Task<long>                         SortedSetCombineAndStoreAsync(SetOperation              operation,       RedisKey            destination,                     RedisKey[]    keys,                           double[]     weights = null,            Aggregate    aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => _db.SortedSetCombineAndStoreAsync(operation: operation, destination: destination, keys: keys, weights: weights, aggregate: aggregate, flags: flags);
    public Task<double>                       SortedSetDecrementAsync(RedisKey                        key,             RedisValue          member,                          double        value,                          CommandFlags flags   = CommandFlags.None) => _db.SortedSetDecrementAsync(key: key, member: member, value: value, flags: flags);
    public Task<double>                       SortedSetIncrementAsync(RedisKey                        key,             RedisValue          member,                          double        value,                          CommandFlags flags   = CommandFlags.None) => _db.SortedSetIncrementAsync(key: key, member: member, value: value, flags: flags);
    public Task<long>                         SortedSetIntersectionLengthAsync(RedisKey[]             keys,            long                limit = 0,                       CommandFlags  flags = CommandFlags.None)                                                                               => _db.SortedSetIntersectionLengthAsync(keys, limit, flags);
    public Task<long>                         SortedSetLengthAsync(RedisKey                           key,             double              min   = double.NegativeInfinity, double        max   = double.PositiveInfinity, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => _db.SortedSetLengthAsync(key: key, min: min, max: max, exclude: exclude, flags: flags);
    public Task<long>                         SortedSetLengthByValueAsync(RedisKey                    key,             RedisValue          min,                             RedisValue    max,                             Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => _db.SortedSetLengthByValueAsync(key: key, min: min, max: max, exclude: exclude, flags: flags);
    public Task<RedisValue>                   SortedSetRandomMemberAsync(RedisKey                     key,             CommandFlags        flags                                                = CommandFlags.None)                                                                                                                                                                                                                                                                                                               => _db.SortedSetRandomMemberAsync(key, flags);
    public Task<RedisValue[]>                 SortedSetRandomMembersAsync(RedisKey                    key,             long                count,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                                                                                                                               => _db.SortedSetRandomMembersAsync(key, count, flags);
    public Task<SortedSetEntry[]>             SortedSetRandomMembersWithScoresAsync(RedisKey          key,             long                count,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                                                                                                                               => _db.SortedSetRandomMembersWithScoresAsync(key, count, flags);
    public Task<RedisValue[]>                 SortedSetRangeByRankAsync(RedisKey                      key,             long                start = 0,                       long          stop  = -1,                                                                                      Order        order = Order.Ascending,   CommandFlags   flags          = CommandFlags.None)                                                                                                                                              => _db.SortedSetRangeByRankAsync(key: key, start: start, stop: stop, order: order, flags: flags);
    public Task<long>                         SortedSetRangeAndStoreAsync(RedisKey                    key,             RedisKey            destinationKey,                  RedisValue    start,                                                                                           RedisValue   stop,                      SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeAndStoreAsync(sourceKey: key, destinationKey: destinationKey, start: start, stop: stop, sortedSetOrder: sortedSetOrder, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public Task<SortedSetEntry[]>             SortedSetRangeByRankWithScoresAsync(RedisKey            key,             long                start = 0,                       long          stop = -1,                                                                                       Order        order   = Order.Ascending, CommandFlags   flags          = CommandFlags.None)                                                                                => _db.SortedSetRangeByRankWithScoresAsync(key: key, start: start, stop: stop, order: order, flags: flags);
    public Task<RedisValue[]>                 SortedSetRangeByScoreAsync(RedisKey                     key,             double              start = double.NegativeInfinity, double        stop = double.PositiveInfinity,                                                                  Exclude      exclude = Exclude.None,    Order          order          = Order.Ascending, long skip = 0,  long         take  = -1, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeByScoreAsync(key: key, start: start, stop: stop, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public Task<SortedSetEntry[]>             SortedSetRangeByScoreWithScoresAsync(RedisKey           key,             double              start = double.NegativeInfinity, double        stop = double.PositiveInfinity,                                                                  Exclude      exclude = Exclude.None,    Order          order          = Order.Ascending, long skip = 0,  long         take  = -1, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeByScoreWithScoresAsync(key: key, start: start, stop: stop, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public Task<RedisValue[]>                 SortedSetRangeByValueAsync(RedisKey                     key,             RedisValue          min,                             RedisValue    max,                                                                                             Exclude      exclude,                   long           skip,                             long take = -1, CommandFlags flags = CommandFlags.None)                          => _db.SortedSetRangeByValueAsync(key: key, min: min, max: max, exclude: exclude, skip: skip, take: take, flags: flags);
    public Task<RedisValue[]>                 SortedSetRangeByValueAsync(RedisKey                     key,             RedisValue          min = new(),                     RedisValue    max                                                                           = new(),           Exclude      exclude = Exclude.None,    Order          order = Order.Ascending,          long skip = 0,  long         take  = -1, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeByValueAsync(key: key, min: min, max: max, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public Task<long?>                        SortedSetRankAsync(RedisKey                             key,             RedisValue          member,                          Order         order                                                                         = Order.Ascending, CommandFlags flags   = CommandFlags.None) => _db.SortedSetRankAsync(key: key, member: member, order: order, flags: flags);
    public Task<bool>                         SortedSetRemoveAsync(RedisKey                           key,             RedisValue          member,                          CommandFlags  flags                                                                         = CommandFlags.None)                                                                 => _db.SortedSetRemoveAsync(key: key, member: member, flags: flags);
    public Task<long>                         SortedSetRemoveAsync(RedisKey                           key,             RedisValue[]        members,                         CommandFlags  flags                                                                         = CommandFlags.None)                                                                 => _db.SortedSetRemoveAsync(key: key, members: members, flags: flags);
    public Task<long>                         SortedSetRemoveRangeByRankAsync(RedisKey                key,             long                start,                           long          stop,                                                    CommandFlags flags   = CommandFlags.None)                                                                 => _db.SortedSetRemoveRangeByRankAsync(key: key, start: start, stop: stop, flags: flags);
    public Task<long>                         SortedSetRemoveRangeByScoreAsync(RedisKey               key,             double              start,                           double        stop,                                                    Exclude      exclude = Exclude.None, CommandFlags flags      = CommandFlags.None)                         => _db.SortedSetRemoveRangeByScoreAsync(key: key, start: start, stop: stop, exclude: exclude, flags: flags);
    public Task<long>                         SortedSetRemoveRangeByValueAsync(RedisKey               key,             RedisValue          min,                             RedisValue    max,                                                     Exclude      exclude = Exclude.None, CommandFlags flags      = CommandFlags.None)                         => _db.SortedSetRemoveRangeByValueAsync(key: key, min: min, max: max, exclude: exclude, flags: flags);
    public IAsyncEnumerable<RedisValue>       SetScanAsync(RedisKey                                   key,             RedisValue          pattern = new(),                 int           pageSize                                          = 250, long         cursor  = 0,            int          pageOffset = 0, CommandFlags flags = CommandFlags.None) => _db.SetScanAsync(key: key, pattern: pattern, pageSize: pageSize, cursor: cursor, pageOffset: pageOffset, flags: flags);
    public IAsyncEnumerable<SortedSetEntry>   SortedSetScanAsync(RedisKey                             key,             RedisValue          pattern = new(),                 int           pageSize                                          = 250, long         cursor  = 0,            int          pageOffset = 0, CommandFlags flags = CommandFlags.None) => _db.SortedSetScanAsync(key: key, pattern: pattern, pageSize: pageSize, cursor: cursor, pageOffset: pageOffset, flags: flags);
    public Task<double?>                      SortedSetScoreAsync(RedisKey                            key,             RedisValue          member,                          CommandFlags  flags                                             = CommandFlags.None)                                            => _db.SortedSetScoreAsync(key: key, member: member, flags: flags);
    public Task<double?[]>                    SortedSetScoresAsync(RedisKey                           key,             RedisValue[]        members,                         CommandFlags  flags                                             = CommandFlags.None)                                            => _db.SortedSetScoresAsync(key, members, flags);
    public Task<bool>                         SortedSetUpdateAsync(RedisKey                           key,             RedisValue          member,                          double        score,                        SortedSetWhen when  = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => _db.SortedSetUpdateAsync(key, member, score, when, flags);
    public Task<long>                         SortedSetUpdateAsync(RedisKey                           key,             SortedSetEntry[]    values,                          SortedSetWhen when  = SortedSetWhen.Always, CommandFlags  flags = CommandFlags.None) => _db.SortedSetUpdateAsync(key, values, when, flags);
    public Task<SortedSetEntry?>              SortedSetPopAsync(RedisKey                              key,             Order               order = Order.Ascending,         CommandFlags  flags = CommandFlags.None)                                                                                                                                                                  => _db.SortedSetPopAsync(key: key, order: order, flags: flags);
    public Task<SortedSetEntry[]>             SortedSetPopAsync(RedisKey                              key,             long                count,                           Order         order = Order.Ascending, CommandFlags flags     = CommandFlags.None)                                                                                                                        => _db.SortedSetPopAsync(key: key, count: count, order: order, flags: flags);
    public Task<SortedSetPopResult>           SortedSetPopAsync(RedisKey[]                            keys,            long                count,                           Order         order = Order.Ascending, CommandFlags flags     = CommandFlags.None)                                                                                                                        => _db.SortedSetPopAsync(keys, count, order, flags);
    public Task<long>                         StreamAcknowledgeAsync(RedisKey                         key,             RedisValue          groupName,                       RedisValue    messageId,               CommandFlags flags     = CommandFlags.None)                                                                                                                        => _db.StreamAcknowledgeAsync(key: key, groupName: groupName, messageId: messageId, flags: flags);
    public Task<long>                         StreamAcknowledgeAsync(RedisKey                         key,             RedisValue          groupName,                       RedisValue[]  messageIds,              CommandFlags flags     = CommandFlags.None)                                                                                                                        => _db.StreamAcknowledgeAsync(key: key, groupName: groupName, messageIds: messageIds, flags: flags);
    public Task<RedisValue>                   StreamAddAsync(RedisKey                                 key,             RedisValue          streamField,                     RedisValue    streamValue,             RedisValue?  messageId = null, int?         maxLength               = null,  bool         useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None) => _db.StreamAddAsync(key: key, streamField: streamField, streamValue: streamValue, messageId: messageId, maxLength: maxLength, useApproximateMaxLength: useApproximateMaxLength, flags: flags);
    public Task<RedisValue>                   StreamAddAsync(RedisKey                                 key,             NameValueEntry[]    streamPairs,                     RedisValue?   messageId = null,        int?         maxLength = null, bool         useApproximateMaxLength = false, CommandFlags flags                   = CommandFlags.None)                            => _db.StreamAddAsync(key: key, streamPairs: streamPairs, messageId: messageId, maxLength: maxLength, useApproximateMaxLength: useApproximateMaxLength, flags: flags);
    public Task<StreamAutoClaimResult>        StreamAutoClaimAsync(RedisKey                           key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,        long         minIdleTimeInMs,  RedisValue   startAtId,                       int?         count                   = null, CommandFlags flags = CommandFlags.None) => _db.StreamAutoClaimAsync(key, consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags);
    public Task<StreamAutoClaimIdsOnlyResult> StreamAutoClaimIdsOnlyAsync(RedisKey                    key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,        long         minIdleTimeInMs,  RedisValue   startAtId,                       int?         count                   = null, CommandFlags flags = CommandFlags.None) => _db.StreamAutoClaimIdsOnlyAsync(key, consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags);
    public Task<StreamEntry[]>                StreamClaimAsync(RedisKey                               key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,        long         minIdleTimeInMs,  RedisValue[] messageIds,                      CommandFlags flags                   = CommandFlags.None) => _db.StreamClaimAsync(key: key, consumerGroup: consumerGroup, claimingConsumer: claimingConsumer, minIdleTimeInMs: minIdleTimeInMs, messageIds: messageIds, flags: flags);
    public Task<RedisValue[]>                 StreamClaimIdsOnlyAsync(RedisKey                        key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,        long         minIdleTimeInMs,  RedisValue[] messageIds,                      CommandFlags flags                   = CommandFlags.None) => _db.StreamClaimIdsOnlyAsync(key: key, consumerGroup: consumerGroup, claimingConsumer: claimingConsumer, minIdleTimeInMs: minIdleTimeInMs, messageIds: messageIds, flags: flags);
    public Task<bool>                         StreamConsumerGroupSetPositionAsync(RedisKey            key,             RedisValue          groupName,                       RedisValue    position,                CommandFlags flags = CommandFlags.None) => _db.StreamConsumerGroupSetPositionAsync(key: key, groupName: groupName, position: position, flags: flags);
    public Task<StreamConsumerInfo[]>         StreamConsumerInfoAsync(RedisKey                        key,             RedisValue          groupName,                       CommandFlags  flags = CommandFlags.None)                                                                                         => _db.StreamConsumerInfoAsync(key: key, groupName: groupName, flags: flags);
    public Task<bool>                         StreamCreateConsumerGroupAsync(RedisKey                 key,             RedisValue          groupName,                       RedisValue?   position,                                CommandFlags flags)                                                       => _db.StreamCreateConsumerGroupAsync(key: key, groupName: groupName, position: position, flags: flags);
    public Task<bool>                         StreamCreateConsumerGroupAsync(RedisKey                 key,             RedisValue          groupName,                       RedisValue?   position                         = null, bool         createStream = true, CommandFlags flags = CommandFlags.None) => _db.StreamCreateConsumerGroupAsync(key: key, groupName: groupName, position: position, createStream: createStream, flags: flags);
    public Task<long>                         StreamDeleteAsync(RedisKey                              key,             RedisValue[]        messageIds,                      CommandFlags  flags                            = CommandFlags.None) => _db.StreamDeleteAsync(key: key, messageIds: messageIds, flags: flags);
    public Task<long>                         StreamDeleteConsumerAsync(RedisKey                      key,             RedisValue          groupName,                       RedisValue    consumerName, CommandFlags flags = CommandFlags.None) => _db.StreamDeleteConsumerAsync(key: key, groupName: groupName, consumerName: consumerName, flags: flags);
    public Task<bool>                         StreamDeleteConsumerGroupAsync(RedisKey                 key,             RedisValue          groupName,                       CommandFlags  flags = CommandFlags.None) => _db.StreamDeleteConsumerGroupAsync(key: key, groupName: groupName, flags: flags);
    public Task<StreamGroupInfo[]>            StreamGroupInfoAsync(RedisKey                           key,             CommandFlags        flags                                                                                                 = CommandFlags.None)                                                                  => _db.StreamGroupInfoAsync(key: key, flags: flags);
    public Task<StreamInfo>                   StreamInfoAsync(RedisKey                                key,             CommandFlags        flags                                                                                                 = CommandFlags.None)                                                                  => _db.StreamInfoAsync(key: key, flags: flags);
    public Task<long>                         StreamLengthAsync(RedisKey                              key,             CommandFlags        flags                                                                                                 = CommandFlags.None)                                                                  => _db.StreamLengthAsync(key: key, flags: flags);
    public Task<StreamPendingInfo>            StreamPendingAsync(RedisKey                             key,             RedisValue          groupName,             CommandFlags flags                                                             = CommandFlags.None)                                                                  => _db.StreamPendingAsync(key: key, groupName: groupName, flags: flags);
    public Task<StreamPendingMessageInfo[]>   StreamPendingMessagesAsync(RedisKey                     key,             RedisValue          groupName,             int          count,        RedisValue   consumerName, RedisValue? minId        = null,            RedisValue?  maxId = null, CommandFlags flags = CommandFlags.None) => _db.StreamPendingMessagesAsync(key: key, groupName: groupName, count: count, consumerName: consumerName, minId: minId, maxId: maxId, flags: flags);
    public Task<StreamEntry[]>                StreamRangeAsync(RedisKey                               key,             RedisValue?         minId = null,          RedisValue?  maxId = null, int?         count = null, Order       messageOrder = Order.Ascending, CommandFlags flags = CommandFlags.None) => _db.StreamRangeAsync(key: key, minId: minId, maxId: maxId, count: count, messageOrder: messageOrder, flags: flags);
    public Task<StreamEntry[]>                StreamReadAsync(RedisKey                                key,             RedisValue          position,              int?         count = null, CommandFlags flags = CommandFlags.None) => _db.StreamReadAsync(key: key, position: position, count: count, flags: flags);
    public Task<RedisStream[]>                StreamReadAsync(StreamPosition[]                        streamPositions, int?                countPerStream = null, CommandFlags flags = CommandFlags.None)                                                                                                                                          => _db.StreamReadAsync(streamPositions: streamPositions, countPerStream: countPerStream, flags: flags);
    public Task<StreamEntry[]>                StreamReadGroupAsync(RedisKey                           key,             RedisValue          groupName,             RedisValue   consumerName,                    RedisValue?  position,              int?         count,        CommandFlags flags)                                                 => _db.StreamReadGroupAsync(key: key, groupName: groupName, consumerName: consumerName, position: position, count: count, flags: flags);
    public Task<StreamEntry[]>                StreamReadGroupAsync(RedisKey                           key,             RedisValue          groupName,             RedisValue   consumerName,                    RedisValue?  position = null,       int?         count = null, bool         noAck = false, CommandFlags flags = CommandFlags.None) => _db.StreamReadGroupAsync(key: key, groupName: groupName, consumerName: consumerName, position: position, count: count, noAck: noAck, flags: flags);
    public Task<RedisStream[]>                StreamReadGroupAsync(StreamPosition[]                   streamPositions, RedisValue          groupName,             RedisValue   consumerName,                    int?         countPerStream,        CommandFlags flags)                                                 => _db.StreamReadGroupAsync(streamPositions: streamPositions, groupName: groupName, consumerName: consumerName, countPerStream: countPerStream, flags: flags);
    public Task<RedisStream[]>                StreamReadGroupAsync(StreamPosition[]                   streamPositions, RedisValue          groupName,             RedisValue   consumerName,                    int?         countPerStream = null, bool         noAck = false, CommandFlags flags = CommandFlags.None) => _db.StreamReadGroupAsync(streamPositions: streamPositions, groupName: groupName, consumerName: consumerName, countPerStream: countPerStream, noAck: noAck, flags: flags);
    public Task<long>                         StreamTrimAsync(RedisKey                                key,             int                 maxLength,             bool         useApproximateMaxLength = false, CommandFlags flags          = CommandFlags.None) => _db.StreamTrimAsync(key: key, maxLength: maxLength, useApproximateMaxLength: useApproximateMaxLength, flags: flags);
    public Task<long>                         StringAppendAsync(RedisKey                              key,             RedisValue          value,                 CommandFlags flags                   = CommandFlags.None)                                                                            => _db.StringAppendAsync(key: key, value: value, flags: flags);
    public Task<long>                         StringBitCountAsync(RedisKey                            key,             long                start = 0,             long         end                     = -1, CommandFlags    flags     = CommandFlags.None)                                            => _db.StringBitCountAsync(key: key, start: start, end: end, flags: flags);
    public Task<long>                         StringBitCountAsync(RedisKey                            key,             long                start = 0,             long         end                     = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => _db.StringBitCountAsync(key, start, end, indexType, flags);
    public Task<long>                         StringBitOperationAsync(Bitwise                         operation,       RedisKey            destination,           RedisKey     first,                        RedisKey        second    = new(),                CommandFlags flags = CommandFlags.None) => _db.StringBitOperationAsync(operation: operation, destination: destination, first: first, second: second, flags: flags);
    public Task<long>                         StringBitOperationAsync(Bitwise                         operation,       RedisKey            destination,           RedisKey[]   keys,                         CommandFlags    flags     = CommandFlags.None)                                                                            => _db.StringBitOperationAsync(operation: operation, destination: destination, keys: keys, flags: flags);
    public Task<long>                         StringBitPositionAsync(RedisKey                         key,             bool                bit,                   long         start = 0,                    long            end       = -1, CommandFlags    flags     = CommandFlags.None)                                            => _db.StringBitPositionAsync(key: key, bit: bit, start: start, end: end, flags: flags);
    public Task<long>                         StringBitPositionAsync(RedisKey                         key,             bool                bit,                   long         start = 0,                    long            end       = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => _db.StringBitPositionAsync(key, bit, start, end, indexType, flags);
    public Task<long>                         StringDecrementAsync(RedisKey                           key,             long                value = 1,             CommandFlags flags = CommandFlags.None) => _db.StringDecrementAsync(key: key, value: value, flags: flags);
    public Task<double>                       StringDecrementAsync(RedisKey                           key,             double              value,                 CommandFlags flags = CommandFlags.None) => _db.StringDecrementAsync(key: key, value: value, flags: flags);
    public Task<RedisValue>                   StringGetAsync(RedisKey                                 key,             CommandFlags        flags                                        = CommandFlags.None) => _db.StringGetAsync(key: key, flags: flags);
    public Task<RedisValue[]>                 StringGetAsync(RedisKey[]                               keys,            CommandFlags        flags                                        = CommandFlags.None) => _db.StringGetAsync(keys: keys, flags: flags);
    public Task<Lease<byte>>                  StringGetLeaseAsync(RedisKey                            key,             CommandFlags        flags                                        = CommandFlags.None) => _db.StringGetLeaseAsync(key: key, flags: flags);
    public Task<bool>                         StringGetBitAsync(RedisKey                              key,             long                offset, CommandFlags flags                   = CommandFlags.None) => _db.StringGetBitAsync(key: key, offset: offset, flags: flags);
    public Task<RedisValue>                   StringGetRangeAsync(RedisKey                            key,             long                start,  long         end, CommandFlags flags = CommandFlags.None) => _db.StringGetRangeAsync(key: key, start: start, end: end, flags: flags);
    public Task<RedisValue>                   StringGetSetAsync(RedisKey                              key,             RedisValue          value,  CommandFlags flags = CommandFlags.None) => _db.StringGetSetAsync(key: key, value: value, flags: flags);
    public Task<RedisValue>                   StringGetSetExpiryAsync(RedisKey                        key,             TimeSpan?           expiry, CommandFlags flags = CommandFlags.None) => _db.StringGetSetExpiryAsync(key: key, expiry: expiry, flags: flags);
    public Task<RedisValue>                   StringGetSetExpiryAsync(RedisKey                        key,             DateTime            expiry, CommandFlags flags = CommandFlags.None) => _db.StringGetSetExpiryAsync(key: key, expiry: expiry, flags: flags);
    public Task<RedisValue>                   StringGetDeleteAsync(RedisKey                           key,             CommandFlags        flags = CommandFlags.None)                         => _db.StringGetDeleteAsync(key: key, flags: flags);
    public Task<RedisValueWithExpiry>         StringGetWithExpiryAsync(RedisKey                       key,             CommandFlags        flags = CommandFlags.None)                         => _db.StringGetWithExpiryAsync(key: key, flags: flags);
    public Task<long>                         StringIncrementAsync(RedisKey                           key,             long                value = 1, CommandFlags flags = CommandFlags.None) => _db.StringIncrementAsync(key: key, value: value, flags: flags);
    public Task<double>                       StringIncrementAsync(RedisKey                           key,             double              value,     CommandFlags flags = CommandFlags.None) => _db.StringIncrementAsync(key: key, value: value, flags: flags);
    public Task<long>                         StringLengthAsync(RedisKey                              key,             CommandFlags        flags                                      = CommandFlags.None)                                                                                               => _db.StringLengthAsync(key: key, flags: flags);
    public Task<string>                       StringLongestCommonSubsequenceAsync(RedisKey            first,           RedisKey            second,             CommandFlags flags     = CommandFlags.None)                                                                                               => _db.StringLongestCommonSubsequenceAsync(first, second, flags);
    public Task<long>                         StringLongestCommonSubsequenceLengthAsync(RedisKey      first,           RedisKey            second,             CommandFlags flags     = CommandFlags.None)                                                                                               => _db.StringLongestCommonSubsequenceLengthAsync(first, second, flags);
    public Task<LCSMatchResult>               StringLongestCommonSubsequenceWithMatchesAsync(RedisKey first,           RedisKey            second,             long         minLength = 0, CommandFlags flags = CommandFlags.None)                                                                       => _db.StringLongestCommonSubsequenceWithMatchesAsync(first, second, minLength, flags);
    public Task<bool>                         StringSetAsync(RedisKey                                 key,             RedisValue          value,              TimeSpan?    expiry,        When         when)                                                                                            => _db.StringSetAsync(key, value, expiry, when);
    public Task<bool>                         StringSetAsync(RedisKey                                 key,             RedisValue          value,              TimeSpan?    expiry = null, When         when    = When.Always, CommandFlags flags = CommandFlags.None)                                   => _db.StringSetAsync(key: key, value: value, expiry: expiry, when: when, flags: flags);
    public Task<bool>                         StringSetAsync(RedisKey                                 key,             RedisValue          value,              TimeSpan?    expiry = null, bool         keepTtl = false,       When         when  = When.Always, CommandFlags flags = CommandFlags.None) => _db.StringSetAsync(key: key, value: value, expiry: expiry, keepTtl: keepTtl, @when: when, flags: flags);
    public Task<bool>                         StringSetAsync(KeyValuePair<RedisKey, RedisValue>[]     values,          When                when = When.Always, CommandFlags flags  = CommandFlags.None)                                                                                           => _db.StringSetAsync(values: values, when: when, flags: flags);
    public Task<RedisValue>                   StringSetAndGetAsync(RedisKey                           key,             RedisValue          value,              TimeSpan?    expiry,        When         when,            CommandFlags flags)                                                      => _db.StringSetAndGetAsync(key: key, value: value, expiry: expiry, @when: when, flags: flags);
    public Task<RedisValue>                   StringSetAndGetAsync(RedisKey                           key,             RedisValue          value,              TimeSpan?    expiry = null, bool         keepTtl = false, When         when = When.Always, CommandFlags flags = CommandFlags.None) => _db.StringSetAndGetAsync(key: key, value: value, expiry: expiry, keepTtl: keepTtl, @when: when, flags: flags);
    public Task<bool>                         StringSetBitAsync(RedisKey                              key,             long                offset,             bool         bit,           CommandFlags flags   = CommandFlags.None) => _db.StringSetBitAsync(key: key, offset: offset, bit: bit, flags: flags);
    public Task<RedisValue>                   StringSetRangeAsync(RedisKey                            key,             long                offset,             RedisValue   value,         CommandFlags flags   = CommandFlags.None) => _db.StringSetRangeAsync(key: key, offset: offset, value: value, flags: flags);
    public Task<bool>                         KeyTouchAsync(RedisKey                                  key,             CommandFlags        flags = CommandFlags.None) => _db.KeyTouchAsync(key: key, flags: flags);
    public Task<long>                         KeyTouchAsync(RedisKey[]                                keys,            CommandFlags        flags = CommandFlags.None) => _db.KeyTouchAsync(keys: keys, flags: flags);
    public IBatch                             CreateBatch(object                                      asyncState                                         = null)                                                                                                                        => _db.CreateBatch(asyncState: asyncState);
    public ITransaction                       CreateTransaction(object                                asyncState                                         = null)                                                                                                                        => _db.CreateTransaction(asyncState: asyncState);
    public void                               KeyMigrate(RedisKey                                     key,         EndPoint     toServer, int toDatabase = 0, int timeoutMilliseconds = 0, MigrateOptions migrateOptions = MigrateOptions.None, CommandFlags flags = CommandFlags.None) => _db.KeyMigrate(key: key, toServer: toServer, toDatabase: toDatabase, timeoutMilliseconds: timeoutMilliseconds, migrateOptions: migrateOptions, flags: flags);
    public RedisValue                         DebugObject(RedisKey                                    key,         CommandFlags flags                                                                          = CommandFlags.None) => _db.DebugObject(key: key, flags: flags);
    public bool                               GeoAdd(RedisKey                                         key,         double       longitude,      double         latitude, RedisValue member, CommandFlags flags = CommandFlags.None) => _db.GeoAdd(key: key, longitude: longitude, latitude: latitude, member: member, flags: flags);
    public bool                               GeoAdd(RedisKey                                         key,         GeoEntry     value,          CommandFlags   flags                 = CommandFlags.None)                                      => _db.GeoAdd(key: key, value: value, flags: flags);
    public long                               GeoAdd(RedisKey                                         key,         GeoEntry[]   values,         CommandFlags   flags                 = CommandFlags.None)                                      => _db.GeoAdd(key: key, values: values, flags: flags);
    public bool                               GeoRemove(RedisKey                                      key,         RedisValue   member,         CommandFlags   flags                 = CommandFlags.None)                                      => _db.GeoRemove(key: key, member: member, flags: flags);
    public double?                            GeoDistance(RedisKey                                    key,         RedisValue   member1,        RedisValue     member2, GeoUnit unit = GeoUnit.Meters, CommandFlags flags = CommandFlags.None) => _db.GeoDistance(key: key, member1: member1, member2: member2, unit: unit, flags: flags);
    public string[]                           GeoHash(RedisKey                                        key,         RedisValue[] members,        CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoHash(key: key, members: members, flags: flags);
    public string                             GeoHash(RedisKey                                        key,         RedisValue   member,         CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoHash(key: key, member: member, flags: flags);
    public GeoPosition?[]                     GeoPosition(RedisKey                                    key,         RedisValue[] members,        CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoPosition(key: key, members: members, flags: flags);
    public GeoPosition?                       GeoPosition(RedisKey                                    key,         RedisValue   member,         CommandFlags   flags                          = CommandFlags.None)                                                                                                                                                                                                                                         => _db.GeoPosition(key: key, member: member, flags: flags);
    public GeoRadiusResult[]                  GeoRadius(RedisKey                                      key,         RedisValue   member,         double         radius,    GeoUnit        unit = GeoUnit.Meters, int            count         = -1,             Order? order         = null, GeoRadiusOptions options       = GeoRadiusOptions.Default, CommandFlags     flags          = CommandFlags.None)                                                => _db.GeoRadius(key: key, member: member, radius: radius, unit: unit, count: count, order: order, options: options, flags: flags);
    public GeoRadiusResult[]                  GeoRadius(RedisKey                                      key,         double       longitude,      double         latitude,  double         radius,                GeoUnit        unit          = GeoUnit.Meters, int    count         = -1,   Order?           order         = null,                     GeoRadiusOptions options        = GeoRadiusOptions.Default, CommandFlags flags = CommandFlags.None) => _db.GeoRadius(key: key, longitude: longitude, latitude: latitude, radius: radius, unit: unit, count: count, order: order, options: options, flags: flags);
    public GeoRadiusResult[]                  GeoSearch(RedisKey                                      key,         RedisValue   member,         GeoSearchShape shape,     int            count = -1,            bool           demandClosest = true,           Order? order         = null, GeoRadiusOptions options       = GeoRadiusOptions.Default, CommandFlags     flags          = CommandFlags.None)                                                                                     => _db.GeoSearch(key, member, shape, count, demandClosest, order, options, flags);
    public GeoRadiusResult[]                  GeoSearch(RedisKey                                      key,         double       longitude,      double         latitude,  GeoSearchShape shape,                 int            count         = -1,             bool   demandClosest = true, Order?           order         = null,                     GeoRadiusOptions options        = GeoRadiusOptions.Default, CommandFlags flags          = CommandFlags.None)                             => _db.GeoSearch(key, longitude, latitude, shape, count, demandClosest, order, options, flags);
    public long                               GeoSearchAndStore(RedisKey                              sourceKey,   RedisKey     destinationKey, RedisValue     member,    GeoSearchShape shape,                 int            count         = -1,             bool   demandClosest = true, Order?           order         = null,                     bool             storeDistances = false,                    CommandFlags flags          = CommandFlags.None)                             => _db.GeoSearchAndStore(sourceKey, destinationKey, member, shape, count, demandClosest, order, storeDistances, flags);
    public long                               GeoSearchAndStore(RedisKey                              sourceKey,   RedisKey     destinationKey, double         longitude, double         latitude,              GeoSearchShape shape,                          int    count         = -1,   bool             demandClosest = true,                     Order?           order          = null,                     bool         storeDistances = false, CommandFlags flags = CommandFlags.None) => _db.GeoSearchAndStore(sourceKey, destinationKey, longitude, latitude, shape, count, demandClosest, order, storeDistances, flags);
    public long                               HashDecrement(RedisKey                                  key,         RedisValue   hashField,      long           value = 1, CommandFlags   flags = CommandFlags.None) => _db.HashDecrement(key: key, hashField: hashField, value: value, flags: flags);
    public double                             HashDecrement(RedisKey                                  key,         RedisValue   hashField,      double         value,     CommandFlags   flags = CommandFlags.None) => _db.HashDecrement(key: key, hashField: hashField, value: value, flags: flags);
    public bool                               HashDelete(RedisKey                                     key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashDelete(key: key, hashField: hashField, flags: flags);
    public long                               HashDelete(RedisKey                                     key,         RedisValue[] hashFields,     CommandFlags   flags = CommandFlags.None) => _db.HashDelete(key: key, hashFields: hashFields, flags: flags);
    public bool                               HashExists(RedisKey                                     key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashExists(key: key, hashField: hashField, flags: flags);
    public RedisValue                         HashGet(RedisKey                                        key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashGet(key: key, hashField: hashField, flags: flags);
    public Lease<byte>                        HashGetLease(RedisKey                                   key,         RedisValue   hashField,      CommandFlags   flags = CommandFlags.None) => _db.HashGetLease(key: key, hashField: hashField, flags: flags);
    public RedisValue[]                       HashGet(RedisKey                                        key,         RedisValue[] hashFields,     CommandFlags   flags = CommandFlags.None) => _db.HashGet(key: key, hashFields: hashFields, flags: flags);
    public HashEntry[]                        HashGetAll(RedisKey                                     key,         CommandFlags flags                   = CommandFlags.None)                         => _db.HashGetAll(key: key, flags: flags);
    public long                               HashIncrement(RedisKey                                  key,         RedisValue   hashField, long   value = 1, CommandFlags flags = CommandFlags.None) => _db.HashIncrement(key: key, hashField: hashField, value: value, flags: flags);
    public double                             HashIncrement(RedisKey                                  key,         RedisValue   hashField, double value,     CommandFlags flags = CommandFlags.None) => _db.HashIncrement(key: key, hashField: hashField, value: value, flags: flags);
    public RedisValue[]                       HashKeys(RedisKey                                       key,         CommandFlags flags                               = CommandFlags.None)                                                                                   => _db.HashKeys(key: key, flags: flags);
    public long                               HashLength(RedisKey                                     key,         CommandFlags flags                               = CommandFlags.None)                                                                                   => _db.HashLength(key: key, flags: flags);
    public RedisValue                         HashRandomField(RedisKey                                key,         CommandFlags flags                               = CommandFlags.None)                                                                                   => _db.HashRandomField(key, flags);
    public RedisValue[]                       HashRandomFields(RedisKey                               key,         long         count,           CommandFlags flags = CommandFlags.None)                                                                                   => _db.HashRandomFields(key, count, flags);
    public HashEntry[]                        HashRandomFieldsWithValues(RedisKey                     key,         long         count,           CommandFlags flags = CommandFlags.None)                                                                                   => _db.HashRandomFieldsWithValues(key, count, flags);
    public IEnumerable<HashEntry>             HashScan(RedisKey                                       key,         RedisValue   pattern,         int          pageSize,               CommandFlags flags)                                                                  => _db.HashScan(key: key, pattern: pattern, pageSize: pageSize, flags: flags);
    public IEnumerable<HashEntry>             HashScan(RedisKey                                       key,         RedisValue   pattern = new(), int          pageSize         = 250, long         cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => _db.HashScan(key: key, pattern: pattern, pageSize: pageSize, cursor: cursor, pageOffset: pageOffset, flags: flags);
    public void                               HashSet(RedisKey                                        key,         HashEntry[]  hashFields,      CommandFlags flags            = CommandFlags.None)                                   => _db.HashSet(key: key, hashFields: hashFields, flags: flags);
    public bool                               HashSet(RedisKey                                        key,         RedisValue   hashField,       RedisValue   value, When when = When.Always, CommandFlags flags = CommandFlags.None) => _db.HashSet(key: key, hashField: hashField, value: value, when: when, flags: flags);
    public long                               HashStringLength(RedisKey                               key,         RedisValue   hashField,       CommandFlags flags = CommandFlags.None) => _db.HashStringLength(key: key, hashField: hashField, flags: flags);
    public RedisValue[]                       HashValues(RedisKey                                     key,         CommandFlags flags                      = CommandFlags.None) => _db.HashValues(key: key, flags: flags);
    public bool                               HyperLogLogAdd(RedisKey                                 key,         RedisValue   value,  CommandFlags flags = CommandFlags.None) => _db.HyperLogLogAdd(key: key, value: value, flags: flags);
    public bool                               HyperLogLogAdd(RedisKey                                 key,         RedisValue[] values, CommandFlags flags = CommandFlags.None) => _db.HyperLogLogAdd(key: key, values: values, flags: flags);
    public long                               HyperLogLogLength(RedisKey                              key,         CommandFlags flags                                               = CommandFlags.None) => _db.HyperLogLogLength(key: key, flags: flags);
    public long                               HyperLogLogLength(RedisKey[]                            keys,        CommandFlags flags                                               = CommandFlags.None) => _db.HyperLogLogLength(keys: keys, flags: flags);
    public void                               HyperLogLogMerge(RedisKey                               destination, RedisKey     first,      RedisKey     second, CommandFlags flags = CommandFlags.None) => _db.HyperLogLogMerge(destination: destination, first: first, second: second, flags: flags);
    public void                               HyperLogLogMerge(RedisKey                               destination, RedisKey[]   sourceKeys, CommandFlags flags = CommandFlags.None) => _db.HyperLogLogMerge(destination: destination, sourceKeys: sourceKeys, flags: flags);
    public EndPoint                           IdentifyEndpoint(RedisKey                               key = new(), CommandFlags flags                                   = CommandFlags.None)                                                => _db.IdentifyEndpoint(key: key, flags: flags);
    public bool                               KeyCopy(RedisKey                                        sourceKey,   RedisKey     destinationKey, int destinationDatabase = -1, bool replace = false, CommandFlags flags = CommandFlags.None) => _db.KeyCopy(sourceKey, destinationKey, destinationDatabase, replace, flags);
    public bool                               KeyDelete(RedisKey                                      key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyDelete(key: key, flags: flags);
    public long                               KeyDelete(RedisKey[]                                    keys,        CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyDelete(keys: keys, flags: flags);
    public byte[]                             KeyDump(RedisKey                                        key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyDump(key: key, flags: flags);
    public string                             KeyEncoding(RedisKey                                    key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyEncoding(key, flags);
    public bool                               KeyExists(RedisKey                                      key,         CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyExists(key: key, flags: flags);
    public long                               KeyExists(RedisKey[]                                    keys,        CommandFlags flags                      = CommandFlags.None)                                         => _db.KeyExists(keys: keys, flags: flags);
    public bool                               KeyExpire(RedisKey                                      key,         TimeSpan?    expiry, CommandFlags flags = CommandFlags.None)                                         => _db.KeyExpire(key: key, expiry: expiry, flags: flags);
    public bool                               KeyExpire(RedisKey                                      key,         TimeSpan?    expiry, ExpireWhen   when  = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => _db.KeyExpire(key, expiry, when, flags);
    public bool                               KeyExpire(RedisKey                                      key,         DateTime?    expiry, CommandFlags flags = CommandFlags.None)                                         => _db.KeyExpire(key: key, expiry: expiry, flags: flags);
    public bool                               KeyExpire(RedisKey                                      key,         DateTime?    expiry, ExpireWhen   when  = ExpireWhen.Always, CommandFlags flags = CommandFlags.None) => _db.KeyExpire(key, expiry, when, flags);
    public DateTime?                          KeyExpireTime(RedisKey                                  key,         CommandFlags flags                        = CommandFlags.None) => _db.KeyExpireTime(key, flags);
    public long?                              KeyFrequency(RedisKey                                   key,         CommandFlags flags                        = CommandFlags.None) => _db.KeyFrequency(key, flags);
    public TimeSpan?                          KeyIdleTime(RedisKey                                    key,         CommandFlags flags                        = CommandFlags.None) => _db.KeyIdleTime(key: key, flags: flags);
    public bool                               KeyMove(RedisKey                                        key,         int          database, CommandFlags flags = CommandFlags.None) => _db.KeyMove(key: key, database: database, flags: flags);
    public bool                               KeyPersist(RedisKey                                     key,         CommandFlags flags = CommandFlags.None) => _db.KeyPersist(key: key, flags: flags);
    public RedisKey                           KeyRandom(CommandFlags                                  flags                                                         = CommandFlags.None)                                   => _db.KeyRandom(flags: flags);
    public long?                              KeyRefCount(RedisKey                                    key,             CommandFlags        flags                    = CommandFlags.None)                                   => _db.KeyRefCount(key, flags);
    public bool                               KeyRename(RedisKey                                      key,             RedisKey            newKey, When      when   = When.Always, CommandFlags flags = CommandFlags.None) => _db.KeyRename(key: key, newKey: newKey, when: when, flags: flags);
    public void                               KeyRestore(RedisKey                                     key,             byte[]              value,  TimeSpan? expiry = null,        CommandFlags flags = CommandFlags.None) => _db.KeyRestore(key: key, value: value, expiry: expiry, flags: flags);
    public TimeSpan?                          KeyTimeToLive(RedisKey                                  key,             CommandFlags        flags                                            = CommandFlags.None)                                                                                                           => _db.KeyTimeToLive(key: key, flags: flags);
    public RedisType                          KeyType(RedisKey                                        key,             CommandFlags        flags                                            = CommandFlags.None)                                                                                                           => _db.KeyType(key: key, flags: flags);
    public Task                               KeyMigrateAsync(RedisKey                                key,             EndPoint            toServer, int          toDatabase                = 0, int timeoutMilliseconds = 0, MigrateOptions migrateOptions = MigrateOptions.None, CommandFlags flags = CommandFlags.None) => _db.KeyMigrateAsync(key: key, toServer: toServer, toDatabase: toDatabase, timeoutMilliseconds: timeoutMilliseconds, migrateOptions: migrateOptions, flags: flags);
    public RedisValue                         ListGetByIndex(RedisKey                                 key,             long                index,    CommandFlags flags                     = CommandFlags.None) => _db.ListGetByIndex(key: key, index: index, flags: flags);
    public long                               ListInsertAfter(RedisKey                                key,             RedisValue          pivot,    RedisValue   value, CommandFlags flags = CommandFlags.None) => _db.ListInsertAfter(key: key, pivot: pivot, value: value, flags: flags);
    public long                               ListInsertBefore(RedisKey                               key,             RedisValue          pivot,    RedisValue   value, CommandFlags flags = CommandFlags.None) => _db.ListInsertBefore(key: key, pivot: pivot, value: value, flags: flags);
    public RedisValue                         ListLeftPop(RedisKey                                    key,             CommandFlags        flags                       = CommandFlags.None)                                                                                          => _db.ListLeftPop(key: key, flags: flags);
    public RedisValue[]                       ListLeftPop(RedisKey                                    key,             long                count,   CommandFlags flags = CommandFlags.None)                                                                                          => _db.ListLeftPop(key: key, count: count, flags: flags);
    public ListPopResult                      ListLeftPop(RedisKey[]                                  keys,            long                count,   CommandFlags flags = CommandFlags.None)                                                                                          => _db.ListLeftPop(keys, count, flags);
    public long                               ListPosition(RedisKey                                   key,             RedisValue          element, long         rank  = 1,          long         maxLength = 0, CommandFlags flags     = CommandFlags.None)                         => _db.ListPosition(key, element, rank, maxLength, flags);
    public long[]                             ListPositions(RedisKey                                  key,             RedisValue          element, long         count,              long         rank      = 1, long         maxLength = 0, CommandFlags flags = CommandFlags.None) => _db.ListPositions(key, element, count, rank, maxLength, flags);
    public long                               ListLeftPush(RedisKey                                   key,             RedisValue          value,   When         when = When.Always, CommandFlags flags     = CommandFlags.None) => _db.ListLeftPush(key: key, value: value, when: when, flags: flags);
    public long                               ListLeftPush(RedisKey                                   key,             RedisValue[]        values,  When         when = When.Always, CommandFlags flags     = CommandFlags.None) => _db.ListLeftPush(key: key, values: values, when: when, flags: flags);
    public long                               ListLeftPush(RedisKey                                   key,             RedisValue[]        values,  CommandFlags flags) => _db.ListLeftPush(key: key, values: values, flags: flags);
    public long                               ListLength(RedisKey                                     key,             CommandFlags        flags                                                                                 = CommandFlags.None) => _db.ListLength(key: key, flags: flags);
    public RedisValue                         ListMove(RedisKey                                       sourceKey,       RedisKey            destinationKey, ListSide sourceSide, ListSide     destinationSide, CommandFlags flags = CommandFlags.None) => _db.ListMove(sourceKey, destinationKey, sourceSide, destinationSide, flags);
    public RedisValue[]                       ListRange(RedisKey                                      key,             long                start = 0,      long     stop  = -1, CommandFlags flags = CommandFlags.None) => _db.ListRange(key: key, start: start, stop: stop, flags: flags);
    public long                               ListRemove(RedisKey                                     key,             RedisValue          value,          long     count = 0,  CommandFlags flags = CommandFlags.None) => _db.ListRemove(key: key, value: value, count: count, flags: flags);
    public RedisValue                         ListRightPop(RedisKey                                   key,             CommandFlags        flags                           = CommandFlags.None)                                   => _db.ListRightPop(key: key, flags: flags);
    public RedisValue[]                       ListRightPop(RedisKey                                   key,             long                count,       CommandFlags flags = CommandFlags.None)                                   => _db.ListRightPop(key: key, count: count, flags: flags);
    public ListPopResult                      ListRightPop(RedisKey[]                                 keys,            long                count,       CommandFlags flags = CommandFlags.None)                                   => _db.ListRightPop(keys, count, flags);
    public RedisValue                         ListRightPopLeftPush(RedisKey                           source,          RedisKey            destination, CommandFlags flags = CommandFlags.None)                                   => _db.ListRightPopLeftPush(source: source, destination: destination, flags: flags);
    public long                               ListRightPush(RedisKey                                  key,             RedisValue          value,       When         when  = When.Always, CommandFlags flags = CommandFlags.None) => _db.ListRightPush(key: key, value: value, when: when, flags: flags);
    public long                               ListRightPush(RedisKey                                  key,             RedisValue[]        values,      When         when  = When.Always, CommandFlags flags = CommandFlags.None) => _db.ListRightPush(key: key, values: values, when: when, flags: flags);
    public long                               ListRightPush(RedisKey                                  key,             RedisValue[]        values,      CommandFlags flags)                                          => _db.ListRightPush(key: key, values: values, flags: flags);
    public void                               ListSetByIndex(RedisKey                                 key,             long                index,       RedisValue   value,  CommandFlags flags = CommandFlags.None) => _db.ListSetByIndex(key: key, index: index, value: value, flags: flags);
    public void                               ListTrim(RedisKey                                       key,             long                start,       long         stop,   CommandFlags flags = CommandFlags.None) => _db.ListTrim(key: key, start: start, stop: stop, flags: flags);
    public bool                               LockExtend(RedisKey                                     key,             RedisValue          value,       TimeSpan     expiry, CommandFlags flags = CommandFlags.None) => _db.LockExtend(key: key, value: value, expiry: expiry, flags: flags);
    public RedisValue                         LockQuery(RedisKey                                      key,             CommandFlags        flags                                            = CommandFlags.None) => _db.LockQuery(key: key, flags: flags);
    public bool                               LockRelease(RedisKey                                    key,             RedisValue          value,   CommandFlags flags                      = CommandFlags.None) => _db.LockRelease(key: key, value: value, flags: flags);
    public bool                               LockTake(RedisKey                                       key,             RedisValue          value,   TimeSpan     expiry, CommandFlags flags = CommandFlags.None) => _db.LockTake(key: key, value: value, expiry: expiry, flags: flags);
    public long                               Publish(RedisChannel                                    channel,         RedisValue          message, CommandFlags flags = CommandFlags.None) => _db.Publish(channel: channel, message: message, flags: flags);
    public RedisResult                        Execute(string                                          command,         params object[]     args)                                                                                                                                          => _db.Execute(command: command, args: args);
    public RedisResult                        Execute(string                                          command,         ICollection<object> args,                                                  CommandFlags flags                      = CommandFlags.None)                            => _db.Execute(command: command, args: args, flags: flags);
    public RedisResult                        ScriptEvaluate(string                                   script,          RedisKey[]          keys       = null,                                     RedisValue[] values                     = null, CommandFlags flags = CommandFlags.None) => _db.ScriptEvaluate(script: script, keys: keys, values: values, flags: flags);
    public RedisResult                        ScriptEvaluate(byte[]                                   hash,            RedisKey[]          keys       = null,                                     RedisValue[] values                     = null, CommandFlags flags = CommandFlags.None) => _db.ScriptEvaluate(hash: hash, keys: keys, values: values, flags: flags);
    public RedisResult                        ScriptEvaluate(LuaScript                                script,          object              parameters = null,                                     CommandFlags flags                      = CommandFlags.None) => _db.ScriptEvaluate(script: script, parameters: parameters, flags: flags);
    public RedisResult                        ScriptEvaluate(LoadedLuaScript                          script,          object              parameters = null,                                     CommandFlags flags                      = CommandFlags.None) => _db.ScriptEvaluate(script: script, parameters: parameters, flags: flags);
    public bool                               SetAdd(RedisKey                                         key,             RedisValue          value,                                                 CommandFlags flags                      = CommandFlags.None) => _db.SetAdd(key: key, value: value, flags: flags);
    public long                               SetAdd(RedisKey                                         key,             RedisValue[]        values,                                                CommandFlags flags                      = CommandFlags.None) => _db.SetAdd(key: key, values: values, flags: flags);
    public RedisValue[]                       SetCombine(SetOperation                                 operation,       RedisKey            first,                                                 RedisKey     second, CommandFlags flags = CommandFlags.None) => _db.SetCombine(operation: operation, first: first, second: second, flags: flags);
    public RedisValue[]                       SetCombine(SetOperation                                 operation,       RedisKey[]          keys,                                                  CommandFlags flags                                          = CommandFlags.None) => _db.SetCombine(operation: operation, keys: keys, flags: flags);
    public long                               SetCombineAndStore(SetOperation                         operation,       RedisKey            destination,                                           RedisKey     first, RedisKey     second, CommandFlags flags = CommandFlags.None) => _db.SetCombineAndStore(operation: operation, destination: destination, first: first, second: second, flags: flags);
    public long                               SetCombineAndStore(SetOperation                         operation,       RedisKey            destination,                                           RedisKey[]   keys,  CommandFlags flags = CommandFlags.None) => _db.SetCombineAndStore(operation: operation, destination: destination, keys: keys, flags: flags);
    public bool                               SetContains(RedisKey                                    key,             RedisValue          value,                                                 CommandFlags flags = CommandFlags.None) => _db.SetContains(key: key, value: value, flags: flags);
    public bool[]                             SetContains(RedisKey                                    key,             RedisValue[]        values,                                                CommandFlags flags = CommandFlags.None) => _db.SetContains(key, values, flags);
    public long                               SetIntersectionLength(RedisKey[]                        keys,            long                limit                                             = 0, CommandFlags flags = CommandFlags.None) => _db.SetIntersectionLength(keys, limit, flags);
    public long                               SetLength(RedisKey                                      key,             CommandFlags        flags                                             = CommandFlags.None) => _db.SetLength(key: key, flags: flags);
    public RedisValue[]                       SetMembers(RedisKey                                     key,             CommandFlags        flags                                             = CommandFlags.None) => _db.SetMembers(key: key, flags: flags);
    public bool                               SetMove(RedisKey                                        source,          RedisKey            destination, RedisValue value, CommandFlags flags = CommandFlags.None) => _db.SetMove(source: source, destination: destination, value: value, flags: flags);
    public RedisValue                         SetPop(RedisKey                                         key,             CommandFlags        flags                     = CommandFlags.None) => _db.SetPop(key: key, flags: flags);
    public RedisValue[]                       SetPop(RedisKey                                         key,             long                count, CommandFlags flags = CommandFlags.None) => _db.SetPop(key: key, count: count, flags: flags);
    public RedisValue                         SetRandomMember(RedisKey                                key,             CommandFlags        flags                                                = CommandFlags.None)                                                                                                                                                                                                             => _db.SetRandomMember(key: key, flags: flags);
    public RedisValue[]                       SetRandomMembers(RedisKey                               key,             long                count,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                             => _db.SetRandomMembers(key: key, count: count, flags: flags);
    public bool                               SetRemove(RedisKey                                      key,             RedisValue          value,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                             => _db.SetRemove(key: key, value: value, flags: flags);
    public long                               SetRemove(RedisKey                                      key,             RedisValue[]        values,                          CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                             => _db.SetRemove(key: key, values: values, flags: flags);
    public IEnumerable<RedisValue>            SetScan(RedisKey                                        key,             RedisValue          pattern,                         int           pageSize,       CommandFlags  flags)                                                                                                                                                                                                   => _db.SetScan(key: key, pattern: pattern, pageSize: pageSize, flags: flags);
    public IEnumerable<RedisValue>            SetScan(RedisKey                                        key,             RedisValue          pattern = new(),                 int           pageSize = 250, long          cursor = 0,               int      pageOffset = 0,                CommandFlags flags    = CommandFlags.None)                                                                                             => _db.SetScan(key: key, pattern: pattern, pageSize: pageSize, cursor: cursor, pageOffset: pageOffset, flags: flags);
    public RedisValue[]                       Sort(RedisKey                                           key,             long                skip    = 0,                     long          take     = -1,  Order         order  = Order.Ascending, SortType sortType   = SortType.Numeric, RedisValue   by       = new(),            RedisValue[] get = null,  CommandFlags flags = CommandFlags.None)                            => _db.Sort(key: key, skip: skip, take: take, order: order, sortType: sortType, by: by, get: get, flags: flags);
    public long                               SortAndStore(RedisKey                                   destination,     RedisKey            key,                             long          skip     = 0,   long          take   = -1,              Order    order      = Order.Ascending,  SortType     sortType = SortType.Numeric, RedisValue   by  = new(), RedisValue[] get   = null, CommandFlags flags = CommandFlags.None) => _db.SortAndStore(destination: destination, key: key, skip: skip, take: take, order: order, sortType: sortType, by: by, get: get, flags: flags);
    public bool                               SortedSetAdd(RedisKey                                   key,             RedisValue          member,                          double        score,          CommandFlags  flags)                                                               => _db.SortedSetAdd(key: key, member: member, score: score, flags: flags);
    public bool                               SortedSetAdd(RedisKey                                   key,             RedisValue          member,                          double        score,          When          when = When.Always,          CommandFlags flags = CommandFlags.None) => _db.SortedSetAdd(key: key, member: member, score: score, when: when, flags: flags);
    public bool                               SortedSetAdd(RedisKey                                   key,             RedisValue          member,                          double        score,          SortedSetWhen when = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => _db.SortedSetAdd(key, member, score, when, flags);
    public long                               SortedSetAdd(RedisKey                                   key,             SortedSetEntry[]    values,                          CommandFlags  flags)                                                                                                                                                  => _db.SortedSetAdd(key: key, values: values, flags: flags);
    public long                               SortedSetAdd(RedisKey                                   key,             SortedSetEntry[]    values,                          When          when    = When.Always,          CommandFlags flags     = CommandFlags.None)                                                                             => _db.SortedSetAdd(key: key, values: values, when: when, flags: flags);
    public long                               SortedSetAdd(RedisKey                                   key,             SortedSetEntry[]    values,                          SortedSetWhen when    = SortedSetWhen.Always, CommandFlags flags     = CommandFlags.None)                                                                             => _db.SortedSetAdd(key, values, when, flags);
    public RedisValue[]                       SortedSetCombine(SetOperation                           operation,       RedisKey[]          keys,                            double[]      weights = null,                 Aggregate    aggregate = Aggregate.Sum, CommandFlags flags     = CommandFlags.None)                                     => _db.SortedSetCombine(operation, keys, weights, aggregate, flags);
    public SortedSetEntry[]                   SortedSetCombineWithScores(SetOperation                 operation,       RedisKey[]          keys,                            double[]      weights = null,                 Aggregate    aggregate = Aggregate.Sum, CommandFlags flags     = CommandFlags.None)                                     => _db.SortedSetCombineWithScores(operation, keys, weights, aggregate, flags);
    public long                               SortedSetCombineAndStore(SetOperation                   operation,       RedisKey            destination,                     RedisKey      first,                          RedisKey     second,                    Aggregate    aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => _db.SortedSetCombineAndStore(operation: operation, destination: destination, first: first, second: second, aggregate: aggregate, flags: flags);
    public long                               SortedSetCombineAndStore(SetOperation                   operation,       RedisKey            destination,                     RedisKey[]    keys,                           double[]     weights = null,            Aggregate    aggregate = Aggregate.Sum, CommandFlags flags = CommandFlags.None) => _db.SortedSetCombineAndStore(operation: operation, destination: destination, keys: keys, weights: weights, aggregate: aggregate, flags: flags);
    public double                             SortedSetDecrement(RedisKey                             key,             RedisValue          member,                          double        value,                          CommandFlags flags   = CommandFlags.None) => _db.SortedSetDecrement(key: key, member: member, value: value, flags: flags);
    public double                             SortedSetIncrement(RedisKey                             key,             RedisValue          member,                          double        value,                          CommandFlags flags   = CommandFlags.None) => _db.SortedSetIncrement(key: key, member: member, value: value, flags: flags);
    public long                               SortedSetIntersectionLength(RedisKey[]                  keys,            long                limit = 0,                       CommandFlags  flags = CommandFlags.None)                                                                               => _db.SortedSetIntersectionLength(keys, limit, flags);
    public long                               SortedSetLength(RedisKey                                key,             double              min   = double.NegativeInfinity, double        max   = double.PositiveInfinity, Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => _db.SortedSetLength(key: key, min: min, max: max, exclude: exclude, flags: flags);
    public long                               SortedSetLengthByValue(RedisKey                         key,             RedisValue          min,                             RedisValue    max,                             Exclude exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => _db.SortedSetLengthByValue(key: key, min: min, max: max, exclude: exclude, flags: flags);
    public RedisValue                         SortedSetRandomMember(RedisKey                          key,             CommandFlags        flags                                                = CommandFlags.None)                                                                                                                                                                                                                                                                      => _db.SortedSetRandomMember(key, flags);
    public RedisValue[]                       SortedSetRandomMembers(RedisKey                         key,             long                count,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                                                                                      => _db.SortedSetRandomMembers(key, count, flags);
    public SortedSetEntry[]                   SortedSetRandomMembersWithScores(RedisKey               key,             long                count,                           CommandFlags  flags = CommandFlags.None)                                                                                                                                                                                                                                                                      => _db.SortedSetRandomMembersWithScores(key, count, flags);
    public RedisValue[]                       SortedSetRangeByRank(RedisKey                           key,             long                start = 0,                       long          stop  = -1,                                             Order        order = Order.Ascending,   CommandFlags   flags          = CommandFlags.None)                                                                                                                                              => _db.SortedSetRangeByRank(key: key, start: start, stop: stop, order: order, flags: flags);
    public long                               SortedSetRangeAndStore(RedisKey                         sourceKey,       RedisKey            destinationKey,                  RedisValue    start,                                                  RedisValue   stop,                      SortedSetOrder sortedSetOrder = SortedSetOrder.ByRank, Exclude exclude = Exclude.None, Order order = Order.Ascending, long skip = 0, long? take = null, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeAndStore(sourceKey: sourceKey, destinationKey: destinationKey, start: start, stop: stop, sortedSetOrder: sortedSetOrder, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public SortedSetEntry[]                   SortedSetRangeByRankWithScores(RedisKey                 key,             long                start = 0,                       long          stop = -1,                                              Order        order   = Order.Ascending, CommandFlags   flags          = CommandFlags.None)                                                                                => _db.SortedSetRangeByRankWithScores(key: key, start: start, stop: stop, order: order, flags: flags);
    public RedisValue[]                       SortedSetRangeByScore(RedisKey                          key,             double              start = double.NegativeInfinity, double        stop = double.PositiveInfinity,                         Exclude      exclude = Exclude.None,    Order          order          = Order.Ascending, long skip = 0,  long         take  = -1, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeByScore(key: key, start: start, stop: stop, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public SortedSetEntry[]                   SortedSetRangeByScoreWithScores(RedisKey                key,             double              start = double.NegativeInfinity, double        stop = double.PositiveInfinity,                         Exclude      exclude = Exclude.None,    Order          order          = Order.Ascending, long skip = 0,  long         take  = -1, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeByScoreWithScores(key: key, start: start, stop: stop, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public RedisValue[]                       SortedSetRangeByValue(RedisKey                          key,             RedisValue          min,                             RedisValue    max,                                                    Exclude      exclude,                   long           skip,                             long take = -1, CommandFlags flags = CommandFlags.None)                          => _db.SortedSetRangeByValue(key: key, min: min, max: max, exclude: exclude, skip: skip, take: take, flags: flags);
    public RedisValue[]                       SortedSetRangeByValue(RedisKey                          key,             RedisValue          min = new(),                     RedisValue    max                                  = new(),           Exclude      exclude = Exclude.None,    Order          order = Order.Ascending,          long skip = 0,  long         take  = -1, CommandFlags flags = CommandFlags.None) => _db.SortedSetRangeByValue(key: key, min: min, max: max, exclude: exclude, order: order, skip: skip, take: take, flags: flags);
    public long?                              SortedSetRank(RedisKey                                  key,             RedisValue          member,                          Order         order                                = Order.Ascending, CommandFlags flags   = CommandFlags.None) => _db.SortedSetRank(key: key, member: member, order: order, flags: flags);
    public bool                               SortedSetRemove(RedisKey                                key,             RedisValue          member,                          CommandFlags  flags                                = CommandFlags.None)                                    => _db.SortedSetRemove(key: key, member: member, flags: flags);
    public long                               SortedSetRemove(RedisKey                                key,             RedisValue[]        members,                         CommandFlags  flags                                = CommandFlags.None)                                    => _db.SortedSetRemove(key: key, members: members, flags: flags);
    public long                               SortedSetRemoveRangeByRank(RedisKey                     key,             long                start,                           long          stop,           CommandFlags flags   = CommandFlags.None)                                    => _db.SortedSetRemoveRangeByRank(key: key, start: start, stop: stop, flags: flags);
    public long                               SortedSetRemoveRangeByScore(RedisKey                    key,             double              start,                           double        stop,           Exclude      exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => _db.SortedSetRemoveRangeByScore(key: key, start: start, stop: stop, exclude: exclude, flags: flags);
    public long                               SortedSetRemoveRangeByValue(RedisKey                    key,             RedisValue          min,                             RedisValue    max,            Exclude      exclude = Exclude.None, CommandFlags flags = CommandFlags.None) => _db.SortedSetRemoveRangeByValue(key: key, min: min, max: max, exclude: exclude, flags: flags);
    public IEnumerable<SortedSetEntry>        SortedSetScan(RedisKey                                  key,             RedisValue          pattern,                         int           pageSize,       CommandFlags flags)                                                                  => _db.SortedSetScan(key: key, pattern: pattern, pageSize: pageSize, flags: flags);
    public IEnumerable<SortedSetEntry>        SortedSetScan(RedisKey                                  key,             RedisValue          pattern = new(),                 int           pageSize = 250, long         cursor = 0, int pageOffset = 0, CommandFlags flags = CommandFlags.None) => _db.SortedSetScan(key: key, pattern: pattern, pageSize: pageSize, cursor: cursor, pageOffset: pageOffset, flags: flags);
    public double?                            SortedSetScore(RedisKey                                 key,             RedisValue          member,                          CommandFlags  flags    = CommandFlags.None)                                                                                        => _db.SortedSetScore(key: key, member: member, flags: flags);
    public double?[]                          SortedSetScores(RedisKey                                key,             RedisValue[]        members,                         CommandFlags  flags    = CommandFlags.None)                                                                                        => _db.SortedSetScores(key, members, flags);
    public SortedSetEntry?                    SortedSetPop(RedisKey                                   key,             Order               order = Order.Ascending,         CommandFlags  flags    = CommandFlags.None)                                                                                        => _db.SortedSetPop(key: key, order: order, flags: flags);
    public SortedSetEntry[]                   SortedSetPop(RedisKey                                   key,             long                count,                           Order         order    = Order.Ascending,  CommandFlags  flags     = CommandFlags.None)                                            => _db.SortedSetPop(key: key, count: count, order: order, flags: flags);
    public SortedSetPopResult                 SortedSetPop(RedisKey[]                                 keys,            long                count,                           Order         order    = Order.Ascending,  CommandFlags  flags     = CommandFlags.None)                                            => _db.SortedSetPop(keys, count, order, flags);
    public bool                               SortedSetUpdate(RedisKey                                key,             RedisValue          member,                          double        score,                       SortedSetWhen when      = SortedSetWhen.Always, CommandFlags flags = CommandFlags.None) => _db.SortedSetUpdate(key, member, score, when, flags);
    public long                               SortedSetUpdate(RedisKey                                key,             SortedSetEntry[]    values,                          SortedSetWhen when = SortedSetWhen.Always, CommandFlags  flags     = CommandFlags.None)                                                                                                                        => _db.SortedSetUpdate(key, values, when, flags);
    public long                               StreamAcknowledge(RedisKey                              key,             RedisValue          groupName,                       RedisValue    messageId,                   CommandFlags  flags     = CommandFlags.None)                                                                                                                        => _db.StreamAcknowledge(key: key, groupName: groupName, messageId: messageId, flags: flags);
    public long                               StreamAcknowledge(RedisKey                              key,             RedisValue          groupName,                       RedisValue[]  messageIds,                  CommandFlags  flags     = CommandFlags.None)                                                                                                                        => _db.StreamAcknowledge(key: key, groupName: groupName, messageIds: messageIds, flags: flags);
    public RedisValue                         StreamAdd(RedisKey                                      key,             RedisValue          streamField,                     RedisValue    streamValue,                 RedisValue?   messageId = null, int?         maxLength               = null,  bool         useApproximateMaxLength = false, CommandFlags flags = CommandFlags.None) => _db.StreamAdd(key: key, streamField: streamField, streamValue: streamValue, messageId: messageId, maxLength: maxLength, useApproximateMaxLength: useApproximateMaxLength, flags: flags);
    public RedisValue                         StreamAdd(RedisKey                                      key,             NameValueEntry[]    streamPairs,                     RedisValue?   messageId = null,            int?          maxLength = null, bool         useApproximateMaxLength = false, CommandFlags flags                   = CommandFlags.None)                            => _db.StreamAdd(key: key, streamPairs: streamPairs, messageId: messageId, maxLength: maxLength, useApproximateMaxLength: useApproximateMaxLength, flags: flags);
    public StreamAutoClaimResult              StreamAutoClaim(RedisKey                                key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,            long          minIdleTimeInMs,  RedisValue   startAtId,                       int?         count                   = null, CommandFlags flags = CommandFlags.None) => _db.StreamAutoClaim(key, consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags);
    public StreamAutoClaimIdsOnlyResult       StreamAutoClaimIdsOnly(RedisKey                         key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,            long          minIdleTimeInMs,  RedisValue   startAtId,                       int?         count                   = null, CommandFlags flags = CommandFlags.None) => _db.StreamAutoClaimIdsOnly(key, consumerGroup, claimingConsumer, minIdleTimeInMs, startAtId, count, flags);
    public StreamEntry[]                      StreamClaim(RedisKey                                    key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,            long          minIdleTimeInMs,  RedisValue[] messageIds,                      CommandFlags flags                   = CommandFlags.None) => _db.StreamClaim(key: key, consumerGroup: consumerGroup, claimingConsumer: claimingConsumer, minIdleTimeInMs: minIdleTimeInMs, messageIds: messageIds, flags: flags);
    public RedisValue[]                       StreamClaimIdsOnly(RedisKey                             key,             RedisValue          consumerGroup,                   RedisValue    claimingConsumer,            long          minIdleTimeInMs,  RedisValue[] messageIds,                      CommandFlags flags                   = CommandFlags.None) => _db.StreamClaimIdsOnly(key: key, consumerGroup: consumerGroup, claimingConsumer: claimingConsumer, minIdleTimeInMs: minIdleTimeInMs, messageIds: messageIds, flags: flags);
    public bool                               StreamConsumerGroupSetPosition(RedisKey                 key,             RedisValue          groupName,                       RedisValue    position,                    CommandFlags  flags = CommandFlags.None) => _db.StreamConsumerGroupSetPosition(key: key, groupName: groupName, position: position, flags: flags);
    public StreamConsumerInfo[]               StreamConsumerInfo(RedisKey                             key,             RedisValue          groupName,                       CommandFlags  flags = CommandFlags.None)                                                                                         => _db.StreamConsumerInfo(key: key, groupName: groupName, flags: flags);
    public bool                               StreamCreateConsumerGroup(RedisKey                      key,             RedisValue          groupName,                       RedisValue?   position,                                CommandFlags flags)                                                       => _db.StreamCreateConsumerGroup(key: key, groupName: groupName, position: position, flags: flags);
    public bool                               StreamCreateConsumerGroup(RedisKey                      key,             RedisValue          groupName,                       RedisValue?   position                         = null, bool         createStream = true, CommandFlags flags = CommandFlags.None) => _db.StreamCreateConsumerGroup(key: key, groupName: groupName, position: position, createStream: createStream, flags: flags);
    public long                               StreamDelete(RedisKey                                   key,             RedisValue[]        messageIds,                      CommandFlags  flags                            = CommandFlags.None) => _db.StreamDelete(key: key, messageIds: messageIds, flags: flags);
    public long                               StreamDeleteConsumer(RedisKey                           key,             RedisValue          groupName,                       RedisValue    consumerName, CommandFlags flags = CommandFlags.None) => _db.StreamDeleteConsumer(key: key, groupName: groupName, consumerName: consumerName, flags: flags);
    public bool                               StreamDeleteConsumerGroup(RedisKey                      key,             RedisValue          groupName,                       CommandFlags  flags = CommandFlags.None) => _db.StreamDeleteConsumerGroup(key: key, groupName: groupName, flags: flags);
    public StreamGroupInfo[]                  StreamGroupInfo(RedisKey                                key,             CommandFlags        flags                                                                                                 = CommandFlags.None)                                                                  => _db.StreamGroupInfo(key: key, flags: flags);
    public StreamInfo                         StreamInfo(RedisKey                                     key,             CommandFlags        flags                                                                                                 = CommandFlags.None)                                                                  => _db.StreamInfo(key: key, flags: flags);
    public long                               StreamLength(RedisKey                                   key,             CommandFlags        flags                                                                                                 = CommandFlags.None)                                                                  => _db.StreamLength(key: key, flags: flags);
    public StreamPendingInfo                  StreamPending(RedisKey                                  key,             RedisValue          groupName,             CommandFlags flags                                                             = CommandFlags.None)                                                                  => _db.StreamPending(key: key, groupName: groupName, flags: flags);
    public StreamPendingMessageInfo[]         StreamPendingMessages(RedisKey                          key,             RedisValue          groupName,             int          count,        RedisValue   consumerName, RedisValue? minId        = null,            RedisValue?  maxId = null, CommandFlags flags = CommandFlags.None) => _db.StreamPendingMessages(key: key, groupName: groupName, count: count, consumerName: consumerName, minId: minId, maxId: maxId, flags: flags);
    public StreamEntry[]                      StreamRange(RedisKey                                    key,             RedisValue?         minId = null,          RedisValue?  maxId = null, int?         count = null, Order       messageOrder = Order.Ascending, CommandFlags flags = CommandFlags.None) => _db.StreamRange(key: key, minId: minId, maxId: maxId, count: count, messageOrder: messageOrder, flags: flags);
    public StreamEntry[]                      StreamRead(RedisKey                                     key,             RedisValue          position,              int?         count = null, CommandFlags flags = CommandFlags.None) => _db.StreamRead(key: key, position: position, count: count, flags: flags);
    public RedisStream[]                      StreamRead(StreamPosition[]                             streamPositions, int?                countPerStream = null, CommandFlags flags = CommandFlags.None)                                                                                                                                          => _db.StreamRead(streamPositions: streamPositions, countPerStream: countPerStream, flags: flags);
    public StreamEntry[]                      StreamReadGroup(RedisKey                                key,             RedisValue          groupName,             RedisValue   consumerName,                    RedisValue?  position,              int?         count,        CommandFlags flags)                                                 => _db.StreamReadGroup(key: key, groupName: groupName, consumerName: consumerName, position: position, count: count, flags: flags);
    public StreamEntry[]                      StreamReadGroup(RedisKey                                key,             RedisValue          groupName,             RedisValue   consumerName,                    RedisValue?  position = null,       int?         count = null, bool         noAck = false, CommandFlags flags = CommandFlags.None) => _db.StreamReadGroup(key: key, groupName: groupName, consumerName: consumerName, position: position, count: count, noAck: noAck, flags: flags);
    public RedisStream[]                      StreamReadGroup(StreamPosition[]                        streamPositions, RedisValue          groupName,             RedisValue   consumerName,                    int?         countPerStream,        CommandFlags flags)                                                 => _db.StreamReadGroup(streamPositions: streamPositions, groupName: groupName, consumerName: consumerName, countPerStream: countPerStream, flags: flags);
    public RedisStream[]                      StreamReadGroup(StreamPosition[]                        streamPositions, RedisValue          groupName,             RedisValue   consumerName,                    int?         countPerStream = null, bool         noAck = false, CommandFlags flags = CommandFlags.None) => _db.StreamReadGroup(streamPositions: streamPositions, groupName: groupName, consumerName: consumerName, countPerStream: countPerStream, noAck: noAck, flags: flags);
    public long                               StreamTrim(RedisKey                                     key,             int                 maxLength,             bool         useApproximateMaxLength = false, CommandFlags flags          = CommandFlags.None) => _db.StreamTrim(key: key, maxLength: maxLength, useApproximateMaxLength: useApproximateMaxLength, flags: flags);
    public long                               StringAppend(RedisKey                                   key,             RedisValue          value,                 CommandFlags flags                   = CommandFlags.None)                                                                            => _db.StringAppend(key: key, value: value, flags: flags);
    public long                               StringBitCount(RedisKey                                 key,             long                start = 0,             long         end                     = -1, CommandFlags    flags     = CommandFlags.None)                                            => _db.StringBitCount(key: key, start: start, end: end, flags: flags);
    public long                               StringBitCount(RedisKey                                 key,             long                start = 0,             long         end                     = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => _db.StringBitCount(key, start, end, indexType, flags);
    public long                               StringBitOperation(Bitwise                              operation,       RedisKey            destination,           RedisKey     first,                        RedisKey        second    = new(),                CommandFlags flags = CommandFlags.None) => _db.StringBitOperation(operation: operation, destination: destination, first: first, second: second, flags: flags);
    public long                               StringBitOperation(Bitwise                              operation,       RedisKey            destination,           RedisKey[]   keys,                         CommandFlags    flags     = CommandFlags.None)                                                                            => _db.StringBitOperation(operation: operation, destination: destination, keys: keys, flags: flags);
    public long                               StringBitPosition(RedisKey                              key,             bool                bit,                   long         start = 0,                    long            end       = -1, CommandFlags    flags     = CommandFlags.None)                                            => _db.StringBitPosition(key: key, bit: bit, start: start, end: end, flags: flags);
    public long                               StringBitPosition(RedisKey                              key,             bool                bit,                   long         start = 0,                    long            end       = -1, StringIndexType indexType = StringIndexType.Byte, CommandFlags flags = CommandFlags.None) => _db.StringBitPosition(key, bit, start, end, indexType, flags);
    public long                               StringDecrement(RedisKey                                key,             long                value = 1,             CommandFlags flags = CommandFlags.None) => _db.StringDecrement(key: key, value: value, flags: flags);
    public double                             StringDecrement(RedisKey                                key,             double              value,                 CommandFlags flags = CommandFlags.None) => _db.StringDecrement(key: key, value: value, flags: flags);
    public RedisValue                         StringGet(RedisKey                                      key,             CommandFlags        flags                                        = CommandFlags.None) => _db.StringGet(key: key, flags: flags);
    public RedisValue[]                       StringGet(RedisKey[]                                    keys,            CommandFlags        flags                                        = CommandFlags.None) => _db.StringGet(keys: keys, flags: flags);
    public Lease<byte>                        StringGetLease(RedisKey                                 key,             CommandFlags        flags                                        = CommandFlags.None) => _db.StringGetLease(key: key, flags: flags);
    public bool                               StringGetBit(RedisKey                                   key,             long                offset, CommandFlags flags                   = CommandFlags.None) => _db.StringGetBit(key: key, offset: offset, flags: flags);
    public RedisValue                         StringGetRange(RedisKey                                 key,             long                start,  long         end, CommandFlags flags = CommandFlags.None) => _db.StringGetRange(key: key, start: start, end: end, flags: flags);
    public RedisValue                         StringGetSet(RedisKey                                   key,             RedisValue          value,  CommandFlags flags = CommandFlags.None) => _db.StringGetSet(key: key, value: value, flags: flags);
    public RedisValue                         StringGetSetExpiry(RedisKey                             key,             TimeSpan?           expiry, CommandFlags flags = CommandFlags.None) => _db.StringGetSetExpiry(key: key, expiry: expiry, flags: flags);
    public RedisValue                         StringGetSetExpiry(RedisKey                             key,             DateTime            expiry, CommandFlags flags = CommandFlags.None) => _db.StringGetSetExpiry(key: key, expiry: expiry, flags: flags);
    public RedisValue                         StringGetDelete(RedisKey                                key,             CommandFlags        flags = CommandFlags.None)                         => _db.StringGetDelete(key: key, flags: flags);
    public RedisValueWithExpiry               StringGetWithExpiry(RedisKey                            key,             CommandFlags        flags = CommandFlags.None)                         => _db.StringGetWithExpiry(key: key, flags: flags);
    public long                               StringIncrement(RedisKey                                key,             long                value = 1, CommandFlags flags = CommandFlags.None) => _db.StringIncrement(key: key, value: value, flags: flags);
    public double                             StringIncrement(RedisKey                                key,             double              value,     CommandFlags flags = CommandFlags.None) => _db.StringIncrement(key: key, value: value, flags: flags);
    public long                               StringLength(RedisKey                                   key,             CommandFlags        flags                          = CommandFlags.None)                         => _db.StringLength(key: key, flags: flags);
    public string                             StringLongestCommonSubsequence(RedisKey                 first,           RedisKey            second, CommandFlags flags     = CommandFlags.None)                         => _db.StringLongestCommonSubsequence(first, second, flags);
    public long                               StringLongestCommonSubsequenceLength(RedisKey           first,           RedisKey            second, CommandFlags flags     = CommandFlags.None)                         => _db.StringLongestCommonSubsequenceLength(first, second, flags);
    public LCSMatchResult                     StringLongestCommonSubsequenceWithMatches(RedisKey      first,           RedisKey            second, long         minLength = 0, CommandFlags flags = CommandFlags.None) => _db.StringLongestCommonSubsequenceWithMatches(first, second, minLength, flags);
    public bool                               StringSet(RedisKey                                      key,             RedisValue          value,  TimeSpan?    expiry,        When         when)                      => _db.StringSet(key, value, expiry, when);
    public bool                             StringSet(RedisKey                                  key,             RedisValue          value,              TimeSpan?    expiry = null, When when    = When.Always, CommandFlags flags = CommandFlags.None)                                   => _db.StringSet(key: key, value: value, expiry: expiry, when: when, flags: flags);
    public bool                             StringSet(RedisKey                                  key,             RedisValue          value,              TimeSpan?    expiry = null, bool keepTtl = false,       When         when  = When.Always, CommandFlags flags = CommandFlags.None) => _db.StringSet(key: key, value: value, expiry: expiry, keepTtl: keepTtl, @when: when, flags: flags);
    public bool                             StringSet(KeyValuePair<RedisKey, RedisValue>[]      values,          When                when = When.Always, CommandFlags flags  = CommandFlags.None)                                                                                           => _db.StringSet(values: values, when: when, flags: flags);
    public RedisValue                       StringSetAndGet(RedisKey                            key,             RedisValue          value,              TimeSpan?    expiry,        When         when,            CommandFlags flags)                                                      => _db.StringSetAndGet(key: key, value: value, expiry: expiry, @when: when, flags: flags);
    public RedisValue                       StringSetAndGet(RedisKey                            key,             RedisValue          value,              TimeSpan?    expiry = null, bool         keepTtl = false, When         when = When.Always, CommandFlags flags = CommandFlags.None) => _db.StringSetAndGet(key: key, value: value, expiry: expiry, keepTtl: keepTtl, @when: when, flags: flags);
    public bool                             StringSetBit(RedisKey                               key,             long                offset,             bool         bit,           CommandFlags flags   = CommandFlags.None) => _db.StringSetBit(key: key, offset: offset, bit: bit, flags: flags);
    public RedisValue                       StringSetRange(RedisKey                             key,             long                offset,             RedisValue   value,         CommandFlags flags   = CommandFlags.None) => _db.StringSetRange(key: key, offset: offset, value: value, flags: flags);
    public bool                             KeyTouch(RedisKey                                   key,             CommandFlags        flags = CommandFlags.None) => _db.KeyTouch(key: key, flags: flags);
    public long                             KeyTouch(RedisKey[]                                 keys,            CommandFlags        flags = CommandFlags.None) => _db.KeyTouch(keys: keys, flags: flags);
}